Copy disabled (too large)
Download .txt
Showing preview only (13,743K chars total). Download the full file to get everything.
Repository: Oxalide/vsphere-influxdb-go
Branch: master
Commit: dac91ccd2de8
Files: 1565
Total size: 12.8 MB
Directory structure:
gitextract_vnb91kqq/
├── .gitignore
├── .travis.yml
├── Dockerfile
├── Gopkg.toml
├── LICENSE.txt
├── README.md
├── goreleaser.yml
├── tools/
│ ├── README.md
│ ├── change_metric_collection_level.py
│ └── requirements.txt
├── vendor/
│ ├── github.com/
│ │ ├── davecgh/
│ │ │ └── go-spew/
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── cov_report.sh
│ │ │ ├── spew/
│ │ │ │ ├── bypass.go
│ │ │ │ ├── bypasssafe.go
│ │ │ │ ├── common.go
│ │ │ │ ├── common_test.go
│ │ │ │ ├── config.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── dump.go
│ │ │ │ ├── dump_test.go
│ │ │ │ ├── dumpcgo_test.go
│ │ │ │ ├── dumpnocgo_test.go
│ │ │ │ ├── example_test.go
│ │ │ │ ├── format.go
│ │ │ │ ├── format_test.go
│ │ │ │ ├── internal_test.go
│ │ │ │ ├── internalunsafe_test.go
│ │ │ │ ├── spew.go
│ │ │ │ ├── spew_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── dumpcgo.go
│ │ │ └── test_coverage.txt
│ │ ├── influxdata/
│ │ │ └── influxdb/
│ │ │ ├── .dockerignore
│ │ │ ├── .github/
│ │ │ │ ├── ISSUE_TEMPLATE.md
│ │ │ │ └── PULL_REQUEST_TEMPLATE.md
│ │ │ ├── .gitignore
│ │ │ ├── .hooks/
│ │ │ │ └── pre-commit
│ │ │ ├── .mention-bot
│ │ │ ├── CHANGELOG.md
│ │ │ ├── CODING_GUIDELINES.md
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── Dockerfile_build_ubuntu32
│ │ │ ├── Dockerfile_build_ubuntu64
│ │ │ ├── Dockerfile_build_ubuntu64_git
│ │ │ ├── Dockerfile_test_ubuntu32
│ │ │ ├── Godeps
│ │ │ ├── LICENSE
│ │ │ ├── LICENSE_OF_DEPENDENCIES.md
│ │ │ ├── Makefile
│ │ │ ├── QUERIES.md
│ │ │ ├── README.md
│ │ │ ├── TODO.md
│ │ │ ├── appveyor.yml
│ │ │ ├── build.py
│ │ │ ├── build.sh
│ │ │ ├── circle-test.sh
│ │ │ ├── circle.yml
│ │ │ ├── client/
│ │ │ │ ├── README.md
│ │ │ │ ├── example_test.go
│ │ │ │ ├── influxdb.go
│ │ │ │ ├── influxdb_test.go
│ │ │ │ └── v2/
│ │ │ │ ├── client.go
│ │ │ │ ├── client_test.go
│ │ │ │ ├── example_test.go
│ │ │ │ └── udp.go
│ │ │ ├── cmd/
│ │ │ │ ├── influx/
│ │ │ │ │ ├── cli/
│ │ │ │ │ │ ├── cli.go
│ │ │ │ │ │ ├── cli_internal_test.go
│ │ │ │ │ │ ├── cli_test.go
│ │ │ │ │ │ ├── parser.go
│ │ │ │ │ │ └── parser_internal_test.go
│ │ │ │ │ └── main.go
│ │ │ │ ├── influx_stress/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ └── template.toml
│ │ │ │ │ └── influx_stress.go
│ │ │ │ ├── influx_tsm/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── b1/
│ │ │ │ │ │ └── reader.go
│ │ │ │ │ ├── bz1/
│ │ │ │ │ │ └── reader.go
│ │ │ │ │ ├── converter.go
│ │ │ │ │ ├── main.go
│ │ │ │ │ ├── stats/
│ │ │ │ │ │ └── stats.go
│ │ │ │ │ ├── tracker.go
│ │ │ │ │ └── tsdb/
│ │ │ │ │ ├── codec.go
│ │ │ │ │ ├── database.go
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ └── meta.pb.go
│ │ │ │ │ └── types.go
│ │ │ │ ├── influxd/
│ │ │ │ │ ├── backup/
│ │ │ │ │ │ └── backup.go
│ │ │ │ │ ├── help/
│ │ │ │ │ │ └── help.go
│ │ │ │ │ ├── main.go
│ │ │ │ │ ├── restore/
│ │ │ │ │ │ └── restore.go
│ │ │ │ │ └── run/
│ │ │ │ │ ├── command.go
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_command.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ └── server.go
│ │ │ │ └── parse.go
│ │ │ ├── coordinator/
│ │ │ │ ├── config.go
│ │ │ │ ├── config_test.go
│ │ │ │ ├── meta_client.go
│ │ │ │ ├── meta_client_test.go
│ │ │ │ ├── points_writer.go
│ │ │ │ ├── points_writer_internal_test.go
│ │ │ │ ├── points_writer_test.go
│ │ │ │ ├── shard_mapper.go
│ │ │ │ ├── shard_mapper_test.go
│ │ │ │ ├── statement_executor.go
│ │ │ │ └── statement_executor_test.go
│ │ │ ├── errors.go
│ │ │ ├── etc/
│ │ │ │ ├── burn-in/
│ │ │ │ │ ├── .rvmrc
│ │ │ │ │ ├── Gemfile
│ │ │ │ │ ├── Gemfile.lock
│ │ │ │ │ ├── burn-in.rb
│ │ │ │ │ ├── log.rb
│ │ │ │ │ ├── random_gaussian.rb
│ │ │ │ │ └── random_points.rb
│ │ │ │ └── config.sample.toml
│ │ │ ├── gobuild.sh
│ │ │ ├── importer/
│ │ │ │ ├── README.md
│ │ │ │ └── v8/
│ │ │ │ └── importer.go
│ │ │ ├── influxdb.go
│ │ │ ├── influxql/
│ │ │ │ ├── README.md
│ │ │ │ ├── ast.go
│ │ │ │ ├── ast_test.go
│ │ │ │ ├── call_iterator.go
│ │ │ │ ├── call_iterator_test.go
│ │ │ │ ├── cast.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── emitter.go
│ │ │ │ ├── emitter_test.go
│ │ │ │ ├── functions.gen.go
│ │ │ │ ├── functions.gen.go.tmpl
│ │ │ │ ├── functions.go
│ │ │ │ ├── functions_test.go
│ │ │ │ ├── influxql.go
│ │ │ │ ├── internal/
│ │ │ │ │ ├── internal.pb.go
│ │ │ │ │ └── internal.proto
│ │ │ │ ├── iterator.gen.go
│ │ │ │ ├── iterator.gen.go.tmpl
│ │ │ │ ├── iterator.go
│ │ │ │ ├── iterator_mapper.go
│ │ │ │ ├── iterator_mapper_test.go
│ │ │ │ ├── iterator_test.go
│ │ │ │ ├── linear.go
│ │ │ │ ├── monitor.go
│ │ │ │ ├── neldermead/
│ │ │ │ │ ├── neldermead.go
│ │ │ │ │ └── neldermead_test.go
│ │ │ │ ├── parser.go
│ │ │ │ ├── parser_test.go
│ │ │ │ ├── point.gen.go
│ │ │ │ ├── point.gen.go.tmpl
│ │ │ │ ├── point.go
│ │ │ │ ├── point_test.go
│ │ │ │ ├── query_executor.go
│ │ │ │ ├── query_executor_test.go
│ │ │ │ ├── result.go
│ │ │ │ ├── sanitize.go
│ │ │ │ ├── sanitize_test.go
│ │ │ │ ├── scanner.go
│ │ │ │ ├── scanner_test.go
│ │ │ │ ├── select.go
│ │ │ │ ├── select_test.go
│ │ │ │ ├── statement_rewriter.go
│ │ │ │ ├── statement_rewriter_test.go
│ │ │ │ ├── subquery.go
│ │ │ │ ├── task_manager.go
│ │ │ │ ├── tmpldata
│ │ │ │ └── token.go
│ │ │ ├── internal/
│ │ │ │ └── meta_client.go
│ │ │ ├── man/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.md
│ │ │ │ ├── footer.txt
│ │ │ │ ├── influx.txt
│ │ │ │ ├── influx_inspect.txt
│ │ │ │ ├── influx_stress.txt
│ │ │ │ ├── influx_tsm.txt
│ │ │ │ ├── influxd-backup.txt
│ │ │ │ ├── influxd-config.txt
│ │ │ │ ├── influxd-restore.txt
│ │ │ │ ├── influxd-run.txt
│ │ │ │ ├── influxd-version.txt
│ │ │ │ └── influxd.txt
│ │ │ ├── models/
│ │ │ │ ├── consistency.go
│ │ │ │ ├── inline_fnv.go
│ │ │ │ ├── inline_fnv_test.go
│ │ │ │ ├── inline_strconv_parse.go
│ │ │ │ ├── inline_strconv_parse_test.go
│ │ │ │ ├── points.go
│ │ │ │ ├── points_internal_test.go
│ │ │ │ ├── points_test.go
│ │ │ │ ├── rows.go
│ │ │ │ ├── statistic.go
│ │ │ │ ├── statistic_test.go
│ │ │ │ └── time.go
│ │ │ ├── monitor/
│ │ │ │ ├── README.md
│ │ │ │ ├── build_info.go
│ │ │ │ ├── config.go
│ │ │ │ ├── config_test.go
│ │ │ │ ├── diagnostics/
│ │ │ │ │ └── diagnostics.go
│ │ │ │ ├── go_runtime.go
│ │ │ │ ├── network.go
│ │ │ │ ├── reporter.go
│ │ │ │ ├── service.go
│ │ │ │ └── system.go
│ │ │ ├── nightly.sh
│ │ │ ├── node.go
│ │ │ ├── pkg/
│ │ │ │ ├── README.md
│ │ │ │ ├── bloom/
│ │ │ │ │ ├── bloom.go
│ │ │ │ │ └── bloom_test.go
│ │ │ │ ├── bytesutil/
│ │ │ │ │ └── bytesutil.go
│ │ │ │ ├── deep/
│ │ │ │ │ └── equal.go
│ │ │ │ ├── escape/
│ │ │ │ │ ├── bytes.go
│ │ │ │ │ ├── bytes_test.go
│ │ │ │ │ ├── strings.go
│ │ │ │ │ └── strings_test.go
│ │ │ │ ├── estimator/
│ │ │ │ │ ├── hll/
│ │ │ │ │ │ ├── compressed.go
│ │ │ │ │ │ ├── empirical_data.go
│ │ │ │ │ │ ├── hll.go
│ │ │ │ │ │ └── hll_test.go
│ │ │ │ │ └── sketch.go
│ │ │ │ ├── limiter/
│ │ │ │ │ └── fixed.go
│ │ │ │ ├── mmap/
│ │ │ │ │ ├── mmap_test.go
│ │ │ │ │ ├── mmap_unix.go
│ │ │ │ │ └── mmap_windows.go
│ │ │ │ ├── pool/
│ │ │ │ │ ├── bytes.go
│ │ │ │ │ ├── bytes_test.go
│ │ │ │ │ └── generic.go
│ │ │ │ ├── rhh/
│ │ │ │ │ ├── rhh.go
│ │ │ │ │ └── rhh_test.go
│ │ │ │ └── slices/
│ │ │ │ └── strings.go
│ │ │ ├── releng/
│ │ │ │ ├── README.md
│ │ │ │ ├── _go_versions.sh
│ │ │ │ ├── raw-binaries/
│ │ │ │ │ ├── Dockerfile
│ │ │ │ │ ├── build.bash
│ │ │ │ │ └── fs/
│ │ │ │ │ └── usr/
│ │ │ │ │ └── local/
│ │ │ │ │ └── bin/
│ │ │ │ │ └── influxdb_raw_binaries.bash
│ │ │ │ ├── source-tarball/
│ │ │ │ │ ├── Dockerfile
│ │ │ │ │ ├── build.bash
│ │ │ │ │ └── fs/
│ │ │ │ │ └── usr/
│ │ │ │ │ └── local/
│ │ │ │ │ └── bin/
│ │ │ │ │ └── influxdb_tarball.bash
│ │ │ │ └── unit-tests/
│ │ │ │ ├── Dockerfile
│ │ │ │ ├── fs/
│ │ │ │ │ └── usr/
│ │ │ │ │ └── local/
│ │ │ │ │ └── bin/
│ │ │ │ │ └── influxdb_prebuild_tests.bash
│ │ │ │ └── run.bash
│ │ │ ├── scripts/
│ │ │ │ ├── influxdb.service
│ │ │ │ ├── init.sh
│ │ │ │ ├── logrotate
│ │ │ │ ├── post-install.sh
│ │ │ │ ├── post-uninstall.sh
│ │ │ │ └── pre-install.sh
│ │ │ ├── services/
│ │ │ │ ├── collectd/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── collectd_test.conf
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── service.go
│ │ │ │ │ ├── service_test.go
│ │ │ │ │ └── test_client/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── client.go
│ │ │ │ ├── continuous_querier/
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── continuous_queries.md
│ │ │ │ │ ├── service.go
│ │ │ │ │ └── service_test.go
│ │ │ │ ├── graphite/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── errors.go
│ │ │ │ │ ├── parser.go
│ │ │ │ │ ├── parser_test.go
│ │ │ │ │ ├── service.go
│ │ │ │ │ └── service_test.go
│ │ │ │ ├── httpd/
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── handler.go
│ │ │ │ │ ├── handler_test.go
│ │ │ │ │ ├── listen.go
│ │ │ │ │ ├── listen_test.go
│ │ │ │ │ ├── pprof.go
│ │ │ │ │ ├── requests.go
│ │ │ │ │ ├── response_logger.go
│ │ │ │ │ ├── response_writer.go
│ │ │ │ │ ├── response_writer_test.go
│ │ │ │ │ └── service.go
│ │ │ │ ├── meta/
│ │ │ │ │ ├── client.go
│ │ │ │ │ ├── client_test.go
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── data.go
│ │ │ │ │ ├── data_internal_test.go
│ │ │ │ │ ├── data_test.go
│ │ │ │ │ ├── errors.go
│ │ │ │ │ ├── file_unix.go
│ │ │ │ │ ├── file_windows.go
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── meta.pb.go
│ │ │ │ │ │ └── meta.proto
│ │ │ │ │ ├── meta_test.go
│ │ │ │ │ ├── query_authorizer.go
│ │ │ │ │ └── write_authorizer.go
│ │ │ │ ├── opentsdb/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── handler.go
│ │ │ │ │ ├── service.go
│ │ │ │ │ └── service_test.go
│ │ │ │ ├── precreator/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── service.go
│ │ │ │ │ └── service_test.go
│ │ │ │ ├── retention/
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ └── service.go
│ │ │ │ ├── snapshotter/
│ │ │ │ │ ├── client.go
│ │ │ │ │ ├── service.go
│ │ │ │ │ └── service_test.go
│ │ │ │ ├── subscriber/
│ │ │ │ │ ├── config.go
│ │ │ │ │ ├── config_test.go
│ │ │ │ │ ├── http.go
│ │ │ │ │ ├── service.go
│ │ │ │ │ ├── service_test.go
│ │ │ │ │ └── udp.go
│ │ │ │ └── udp/
│ │ │ │ ├── README.md
│ │ │ │ ├── config.go
│ │ │ │ ├── config_test.go
│ │ │ │ ├── service.go
│ │ │ │ └── service_test.go
│ │ │ ├── stress/
│ │ │ │ ├── DESIGN.md
│ │ │ │ ├── README.md
│ │ │ │ ├── basic.go
│ │ │ │ ├── config.go
│ │ │ │ ├── run.go
│ │ │ │ ├── stress.toml
│ │ │ │ ├── stress_test.go
│ │ │ │ ├── stress_test_server/
│ │ │ │ │ └── server.go
│ │ │ │ ├── template.go
│ │ │ │ ├── util.go
│ │ │ │ └── v2/
│ │ │ │ ├── DESIGN.md
│ │ │ │ ├── README.md
│ │ │ │ ├── iql/
│ │ │ │ │ ├── default.iql
│ │ │ │ │ └── file.iql
│ │ │ │ ├── main.go
│ │ │ │ ├── statement/
│ │ │ │ │ ├── exec.go
│ │ │ │ │ ├── exec_test.go
│ │ │ │ │ ├── function.go
│ │ │ │ │ ├── function_test.go
│ │ │ │ │ ├── go.go
│ │ │ │ │ ├── go_test.go
│ │ │ │ │ ├── influxql.go
│ │ │ │ │ ├── influxql_test.go
│ │ │ │ │ ├── insert.go
│ │ │ │ │ ├── insert_test.go
│ │ │ │ │ ├── query.go
│ │ │ │ │ ├── query_test.go
│ │ │ │ │ ├── report.go
│ │ │ │ │ ├── report_test.go
│ │ │ │ │ ├── response_time.go
│ │ │ │ │ ├── response_time_test.go
│ │ │ │ │ ├── set.go
│ │ │ │ │ ├── set_test.go
│ │ │ │ │ ├── statement.go
│ │ │ │ │ ├── template.go
│ │ │ │ │ ├── template_test.go
│ │ │ │ │ ├── timestamp.go
│ │ │ │ │ ├── timestamp_test.go
│ │ │ │ │ ├── wait.go
│ │ │ │ │ └── wait_test.go
│ │ │ │ ├── stress_client/
│ │ │ │ │ ├── commune.go
│ │ │ │ │ ├── commune_test.go
│ │ │ │ │ ├── directive.go
│ │ │ │ │ ├── directive_test.go
│ │ │ │ │ ├── package.go
│ │ │ │ │ ├── package_test.go
│ │ │ │ │ ├── reporting.go
│ │ │ │ │ ├── reporting_test.go
│ │ │ │ │ ├── response.go
│ │ │ │ │ ├── response_test.go
│ │ │ │ │ ├── stressTest.go
│ │ │ │ │ ├── stressTest_test.go
│ │ │ │ │ ├── stress_client.go
│ │ │ │ │ ├── stress_client_query.go
│ │ │ │ │ ├── stress_client_write.go
│ │ │ │ │ ├── tracer.go
│ │ │ │ │ ├── tracer_test.go
│ │ │ │ │ └── util.go
│ │ │ │ └── stressql/
│ │ │ │ ├── parser.go
│ │ │ │ ├── parser_test.go
│ │ │ │ └── statement/
│ │ │ │ ├── parser.go
│ │ │ │ └── parser_test.go
│ │ │ ├── tcp/
│ │ │ │ ├── mux.go
│ │ │ │ └── mux_test.go
│ │ │ ├── test.sh
│ │ │ ├── tests/
│ │ │ │ ├── README.md
│ │ │ │ ├── backup_restore_test.go
│ │ │ │ ├── server_bench_test.go
│ │ │ │ ├── server_helpers.go
│ │ │ │ ├── server_suite.go
│ │ │ │ └── server_test.go
│ │ │ ├── toml/
│ │ │ │ ├── toml.go
│ │ │ │ └── toml_test.go
│ │ │ ├── tsdb/
│ │ │ │ ├── README.md
│ │ │ │ ├── batcher.go
│ │ │ │ ├── batcher_test.go
│ │ │ │ ├── config.go
│ │ │ │ ├── config_test.go
│ │ │ │ ├── cursor.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── engine/
│ │ │ │ │ ├── engine.go
│ │ │ │ │ └── tsm1/
│ │ │ │ │ ├── DESIGN.md
│ │ │ │ │ ├── MANIFEST
│ │ │ │ │ ├── bit_reader.go
│ │ │ │ │ ├── bit_reader_test.go
│ │ │ │ │ ├── bool.go
│ │ │ │ │ ├── bool_test.go
│ │ │ │ │ ├── cache.go
│ │ │ │ │ ├── cache_race_test.go
│ │ │ │ │ ├── cache_test.go
│ │ │ │ │ ├── compact.gen.go
│ │ │ │ │ ├── compact.gen.go.tmpl
│ │ │ │ │ ├── compact.gen.go.tmpldata
│ │ │ │ │ ├── compact.go
│ │ │ │ │ ├── compact_test.go
│ │ │ │ │ ├── cursor.go
│ │ │ │ │ ├── encoding.gen.go
│ │ │ │ │ ├── encoding.gen.go.tmpl
│ │ │ │ │ ├── encoding.gen.go.tmpldata
│ │ │ │ │ ├── encoding.go
│ │ │ │ │ ├── encoding_test.go
│ │ │ │ │ ├── engine.go
│ │ │ │ │ ├── engine_test.go
│ │ │ │ │ ├── file_store.gen.go
│ │ │ │ │ ├── file_store.gen.go.tmpl
│ │ │ │ │ ├── file_store.gen.go.tmpldata
│ │ │ │ │ ├── file_store.go
│ │ │ │ │ ├── file_store_internal_test.go
│ │ │ │ │ ├── file_store_test.go
│ │ │ │ │ ├── file_unix.go
│ │ │ │ │ ├── file_windows.go
│ │ │ │ │ ├── float.go
│ │ │ │ │ ├── float_test.go
│ │ │ │ │ ├── int.go
│ │ │ │ │ ├── int_test.go
│ │ │ │ │ ├── iterator.gen.go
│ │ │ │ │ ├── iterator.gen.go.tmpl
│ │ │ │ │ ├── iterator.gen.go.tmpldata
│ │ │ │ │ ├── iterator.go
│ │ │ │ │ ├── mmap_solaris.go
│ │ │ │ │ ├── mmap_unix.go
│ │ │ │ │ ├── mmap_windows.go
│ │ │ │ │ ├── pools.go
│ │ │ │ │ ├── reader.go
│ │ │ │ │ ├── reader_test.go
│ │ │ │ │ ├── ring.go
│ │ │ │ │ ├── ring_test.go
│ │ │ │ │ ├── string.go
│ │ │ │ │ ├── string_test.go
│ │ │ │ │ ├── timestamp.go
│ │ │ │ │ ├── timestamp_test.go
│ │ │ │ │ ├── tombstone.go
│ │ │ │ │ ├── tombstone_test.go
│ │ │ │ │ ├── wal.go
│ │ │ │ │ ├── wal_test.go
│ │ │ │ │ ├── writer.go
│ │ │ │ │ └── writer_test.go
│ │ │ │ ├── engine.go
│ │ │ │ ├── index/
│ │ │ │ │ ├── index.go
│ │ │ │ │ ├── inmem/
│ │ │ │ │ │ ├── inmem.go
│ │ │ │ │ │ ├── meta.go
│ │ │ │ │ │ └── meta_test.go
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ └── file_set.go
│ │ │ │ │ └── tsi1/
│ │ │ │ │ ├── doc.go
│ │ │ │ │ ├── file_set.go
│ │ │ │ │ ├── file_set_test.go
│ │ │ │ │ ├── index.go
│ │ │ │ │ ├── index_file.go
│ │ │ │ │ ├── index_file_test.go
│ │ │ │ │ ├── index_files.go
│ │ │ │ │ ├── index_files_test.go
│ │ │ │ │ ├── index_test.go
│ │ │ │ │ ├── log_file.go
│ │ │ │ │ ├── log_file_test.go
│ │ │ │ │ ├── measurement_block.go
│ │ │ │ │ ├── measurement_block_test.go
│ │ │ │ │ ├── series_block.go
│ │ │ │ │ ├── series_block_test.go
│ │ │ │ │ ├── tag_block.go
│ │ │ │ │ ├── tag_block_test.go
│ │ │ │ │ ├── tsi1.go
│ │ │ │ │ └── tsi1_test.go
│ │ │ │ ├── index.go
│ │ │ │ ├── internal/
│ │ │ │ │ ├── meta.pb.go
│ │ │ │ │ └── meta.proto
│ │ │ │ ├── meta.go
│ │ │ │ ├── meta_test.go
│ │ │ │ ├── shard.go
│ │ │ │ ├── shard_internal_test.go
│ │ │ │ ├── shard_test.go
│ │ │ │ ├── store.go
│ │ │ │ ├── store_internal_test.go
│ │ │ │ └── store_test.go
│ │ │ └── uuid/
│ │ │ └── uuid.go
│ │ └── vmware/
│ │ └── govmomi/
│ │ ├── .drone.sec
│ │ ├── .drone.yml
│ │ ├── .gitignore
│ │ ├── .mailmap
│ │ ├── .travis.yml
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── CONTRIBUTORS
│ │ ├── LICENSE.txt
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── client.go
│ │ ├── client_test.go
│ │ ├── event/
│ │ │ ├── history_collector.go
│ │ │ ├── manager.go
│ │ │ ├── processor.go
│ │ │ └── sort.go
│ │ ├── examples/
│ │ │ ├── datastores/
│ │ │ │ └── main.go
│ │ │ ├── examples.go
│ │ │ ├── hosts/
│ │ │ │ └── main.go
│ │ │ ├── networks/
│ │ │ │ └── main.go
│ │ │ └── virtualmachines/
│ │ │ └── main.go
│ │ ├── find/
│ │ │ ├── doc.go
│ │ │ ├── error.go
│ │ │ ├── finder.go
│ │ │ └── recurser.go
│ │ ├── gen/
│ │ │ ├── Gemfile
│ │ │ ├── gen.sh
│ │ │ ├── gen_from_vmodl.rb
│ │ │ ├── gen_from_wsdl.rb
│ │ │ └── vim_wsdl.rb
│ │ ├── govc/
│ │ │ ├── .gitignore
│ │ │ ├── CHANGELOG.md
│ │ │ ├── README.md
│ │ │ ├── USAGE.md
│ │ │ ├── about/
│ │ │ │ ├── cert.go
│ │ │ │ └── command.go
│ │ │ ├── build.sh
│ │ │ ├── cli/
│ │ │ │ ├── command.go
│ │ │ │ └── register.go
│ │ │ ├── cluster/
│ │ │ │ ├── add.go
│ │ │ │ ├── change.go
│ │ │ │ └── create.go
│ │ │ ├── datacenter/
│ │ │ │ ├── create.go
│ │ │ │ └── info.go
│ │ │ ├── datastore/
│ │ │ │ ├── cp.go
│ │ │ │ ├── create.go
│ │ │ │ ├── disk/
│ │ │ │ │ ├── create.go
│ │ │ │ │ └── info.go
│ │ │ │ ├── download.go
│ │ │ │ ├── info.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── mkdir.go
│ │ │ │ ├── mv.go
│ │ │ │ ├── remove.go
│ │ │ │ ├── rm.go
│ │ │ │ ├── tail.go
│ │ │ │ ├── upload.go
│ │ │ │ └── vsan/
│ │ │ │ ├── ls.go
│ │ │ │ └── rm.go
│ │ │ ├── device/
│ │ │ │ ├── boot.go
│ │ │ │ ├── cdrom/
│ │ │ │ │ ├── add.go
│ │ │ │ │ ├── eject.go
│ │ │ │ │ └── insert.go
│ │ │ │ ├── connect.go
│ │ │ │ ├── disconnect.go
│ │ │ │ ├── floppy/
│ │ │ │ │ ├── add.go
│ │ │ │ │ ├── eject.go
│ │ │ │ │ └── insert.go
│ │ │ │ ├── info.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── remove.go
│ │ │ │ ├── scsi/
│ │ │ │ │ └── add.go
│ │ │ │ ├── serial/
│ │ │ │ │ ├── add.go
│ │ │ │ │ ├── connect.go
│ │ │ │ │ └── disconnect.go
│ │ │ │ └── usb/
│ │ │ │ └── add.go
│ │ │ ├── dvs/
│ │ │ │ ├── add.go
│ │ │ │ ├── create.go
│ │ │ │ └── portgroup/
│ │ │ │ ├── add.go
│ │ │ │ ├── change.go
│ │ │ │ ├── info.go
│ │ │ │ └── spec.go
│ │ │ ├── emacs/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── Cask
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.md
│ │ │ │ ├── govc.el
│ │ │ │ └── test/
│ │ │ │ ├── govc-test.el
│ │ │ │ └── make.el
│ │ │ ├── env/
│ │ │ │ └── command.go
│ │ │ ├── events/
│ │ │ │ └── command.go
│ │ │ ├── examples/
│ │ │ │ ├── lib/
│ │ │ │ │ └── ssh.sh
│ │ │ │ └── vcsa.sh
│ │ │ ├── extension/
│ │ │ │ ├── info.go
│ │ │ │ ├── register.go
│ │ │ │ ├── setcert.go
│ │ │ │ └── unregister.go
│ │ │ ├── fields/
│ │ │ │ ├── add.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── rename.go
│ │ │ │ ├── rm.go
│ │ │ │ └── set.go
│ │ │ ├── flags/
│ │ │ │ ├── client.go
│ │ │ │ ├── common.go
│ │ │ │ ├── datacenter.go
│ │ │ │ ├── datastore.go
│ │ │ │ ├── debug.go
│ │ │ │ ├── empty.go
│ │ │ │ ├── folder.go
│ │ │ │ ├── host_connect.go
│ │ │ │ ├── host_system.go
│ │ │ │ ├── int32.go
│ │ │ │ ├── network.go
│ │ │ │ ├── optional_bool.go
│ │ │ │ ├── optional_bool_test.go
│ │ │ │ ├── output.go
│ │ │ │ ├── resource_pool.go
│ │ │ │ ├── search.go
│ │ │ │ ├── storage_pod.go
│ │ │ │ ├── version.go
│ │ │ │ ├── version_test.go
│ │ │ │ ├── virtual_app.go
│ │ │ │ └── virtual_machine.go
│ │ │ ├── folder/
│ │ │ │ ├── create.go
│ │ │ │ └── info.go
│ │ │ ├── host/
│ │ │ │ ├── account/
│ │ │ │ │ ├── account.go
│ │ │ │ │ ├── create.go
│ │ │ │ │ ├── remove.go
│ │ │ │ │ └── update.go
│ │ │ │ ├── add.go
│ │ │ │ ├── autostart/
│ │ │ │ │ ├── add.go
│ │ │ │ │ ├── autostart.go
│ │ │ │ │ ├── configure.go
│ │ │ │ │ ├── info.go
│ │ │ │ │ └── remove.go
│ │ │ │ ├── cert/
│ │ │ │ │ ├── csr.go
│ │ │ │ │ ├── info.go
│ │ │ │ │ └── install.go
│ │ │ │ ├── date/
│ │ │ │ │ ├── change.go
│ │ │ │ │ └── info.go
│ │ │ │ ├── disconnect.go
│ │ │ │ ├── esxcli/
│ │ │ │ │ ├── command.go
│ │ │ │ │ ├── command_test.go
│ │ │ │ │ ├── esxcli.go
│ │ │ │ │ ├── executor.go
│ │ │ │ │ ├── firewall_info.go
│ │ │ │ │ ├── fixtures/
│ │ │ │ │ │ ├── network_vm_list.xml
│ │ │ │ │ │ ├── network_vm_port_list.xml
│ │ │ │ │ │ └── system_hostname_get.xml
│ │ │ │ │ ├── guest_info.go
│ │ │ │ │ ├── response.go
│ │ │ │ │ └── response_test.go
│ │ │ │ ├── firewall/
│ │ │ │ │ └── find.go
│ │ │ │ ├── info.go
│ │ │ │ ├── maintenance/
│ │ │ │ │ ├── enter.go
│ │ │ │ │ └── exit.go
│ │ │ │ ├── option/
│ │ │ │ │ ├── ls.go
│ │ │ │ │ └── set.go
│ │ │ │ ├── portgroup/
│ │ │ │ │ ├── add.go
│ │ │ │ │ ├── change.go
│ │ │ │ │ ├── info.go
│ │ │ │ │ └── remove.go
│ │ │ │ ├── reconnect.go
│ │ │ │ ├── remove.go
│ │ │ │ ├── service/
│ │ │ │ │ ├── command.go
│ │ │ │ │ └── ls.go
│ │ │ │ ├── shutdown.go
│ │ │ │ ├── storage/
│ │ │ │ │ ├── info.go
│ │ │ │ │ ├── mark.go
│ │ │ │ │ └── partition.go
│ │ │ │ ├── vnic/
│ │ │ │ │ ├── info.go
│ │ │ │ │ └── service.go
│ │ │ │ └── vswitch/
│ │ │ │ ├── add.go
│ │ │ │ ├── info.go
│ │ │ │ └── remove.go
│ │ │ ├── importx/
│ │ │ │ ├── archive.go
│ │ │ │ ├── folder.go
│ │ │ │ ├── importable.go
│ │ │ │ ├── lease_updater.go
│ │ │ │ ├── options.go
│ │ │ │ ├── ova.go
│ │ │ │ ├── ovf.go
│ │ │ │ ├── spec.go
│ │ │ │ └── vmdk.go
│ │ │ ├── license/
│ │ │ │ ├── add.go
│ │ │ │ ├── assign.go
│ │ │ │ ├── assigned.go
│ │ │ │ ├── decode.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── output.go
│ │ │ │ └── remove.go
│ │ │ ├── logs/
│ │ │ │ ├── command.go
│ │ │ │ ├── download.go
│ │ │ │ └── ls.go
│ │ │ ├── ls/
│ │ │ │ └── command.go
│ │ │ ├── main.go
│ │ │ ├── main_test.go
│ │ │ ├── metric/
│ │ │ │ ├── change.go
│ │ │ │ ├── info.go
│ │ │ │ ├── interval/
│ │ │ │ │ ├── change.go
│ │ │ │ │ └── info.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── performance.go
│ │ │ │ ├── reset.go
│ │ │ │ └── sample.go
│ │ │ ├── object/
│ │ │ │ ├── collect.go
│ │ │ │ ├── destroy.go
│ │ │ │ ├── find.go
│ │ │ │ ├── method.go
│ │ │ │ ├── mv.go
│ │ │ │ ├── reload.go
│ │ │ │ └── rename.go
│ │ │ ├── option/
│ │ │ │ ├── ls.go
│ │ │ │ └── set.go
│ │ │ ├── permissions/
│ │ │ │ ├── ls.go
│ │ │ │ ├── permissions.go
│ │ │ │ ├── remove.go
│ │ │ │ └── set.go
│ │ │ ├── pool/
│ │ │ │ ├── change.go
│ │ │ │ ├── create.go
│ │ │ │ ├── destroy.go
│ │ │ │ ├── help.go
│ │ │ │ ├── info.go
│ │ │ │ └── resource_config_spec.go
│ │ │ ├── release.sh
│ │ │ ├── role/
│ │ │ │ ├── create.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── remove.go
│ │ │ │ ├── update.go
│ │ │ │ └── usage.go
│ │ │ ├── session/
│ │ │ │ ├── ls.go
│ │ │ │ └── rm.go
│ │ │ ├── test/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── README.md
│ │ │ │ ├── boot_order_test.sh
│ │ │ │ ├── clean.sh
│ │ │ │ ├── cli.bats
│ │ │ │ ├── datacenter.bats
│ │ │ │ ├── datastore.bats
│ │ │ │ ├── datastore_file_manager_test.sh
│ │ │ │ ├── datastore_tail_test.sh
│ │ │ │ ├── device.bats
│ │ │ │ ├── esxbox/
│ │ │ │ │ └── Vagrantfile
│ │ │ │ ├── esxcli.bats
│ │ │ │ ├── events.bats
│ │ │ │ ├── extension.bats
│ │ │ │ ├── fields.bats
│ │ │ │ ├── firewall.bats
│ │ │ │ ├── folder.bats
│ │ │ │ ├── govc-sim
│ │ │ │ ├── guest_operations_test.sh
│ │ │ │ ├── host.bats
│ │ │ │ ├── host_cert_sign.sh
│ │ │ │ ├── images/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ └── update.sh
│ │ │ │ ├── import.bats
│ │ │ │ ├── license.bats
│ │ │ │ ├── logs.bats
│ │ │ │ ├── ls.bats
│ │ │ │ ├── metric.bats
│ │ │ │ ├── metric_info_test.sh
│ │ │ │ ├── network.bats
│ │ │ │ ├── object.bats
│ │ │ │ ├── pool.bats
│ │ │ │ ├── role.bats
│ │ │ │ ├── session.bats
│ │ │ │ ├── test_helper.bash
│ │ │ │ ├── vcsim/
│ │ │ │ │ ├── Vagrantfile
│ │ │ │ │ └── provision.sh
│ │ │ │ └── vm.bats
│ │ │ ├── usage.sh
│ │ │ ├── vapp/
│ │ │ │ ├── destroy.go
│ │ │ │ └── power.go
│ │ │ ├── version/
│ │ │ │ └── command.go
│ │ │ └── vm/
│ │ │ ├── change.go
│ │ │ ├── clone.go
│ │ │ ├── create.go
│ │ │ ├── destroy.go
│ │ │ ├── disk/
│ │ │ │ ├── attach.go
│ │ │ │ ├── change.go
│ │ │ │ └── create.go
│ │ │ ├── guest/
│ │ │ │ ├── auth.go
│ │ │ │ ├── chmod.go
│ │ │ │ ├── chown.go
│ │ │ │ ├── download.go
│ │ │ │ ├── file_attr.go
│ │ │ │ ├── getenv.go
│ │ │ │ ├── guest.go
│ │ │ │ ├── kill.go
│ │ │ │ ├── ls.go
│ │ │ │ ├── mkdir.go
│ │ │ │ ├── mktemp.go
│ │ │ │ ├── mv.go
│ │ │ │ ├── ps.go
│ │ │ │ ├── rm.go
│ │ │ │ ├── rmdir.go
│ │ │ │ ├── start.go
│ │ │ │ ├── tools.go
│ │ │ │ ├── touch.go
│ │ │ │ └── upload.go
│ │ │ ├── info.go
│ │ │ ├── ip.go
│ │ │ ├── markastemplate.go
│ │ │ ├── markasvm.go
│ │ │ ├── migrate.go
│ │ │ ├── network/
│ │ │ │ ├── add.go
│ │ │ │ └── change.go
│ │ │ ├── power.go
│ │ │ ├── question.go
│ │ │ ├── rdm/
│ │ │ │ ├── attach.go
│ │ │ │ └── ls.go
│ │ │ ├── register.go
│ │ │ ├── snapshot/
│ │ │ │ ├── create.go
│ │ │ │ ├── remove.go
│ │ │ │ ├── revert.go
│ │ │ │ └── tree.go
│ │ │ ├── unregister.go
│ │ │ └── vnc.go
│ │ ├── guest/
│ │ │ ├── auth_manager.go
│ │ │ ├── file_manager.go
│ │ │ ├── operations_manager.go
│ │ │ └── process_manager.go
│ │ ├── license/
│ │ │ ├── assignment_manager.go
│ │ │ └── manager.go
│ │ ├── list/
│ │ │ ├── lister.go
│ │ │ ├── path.go
│ │ │ └── path_test.go
│ │ ├── object/
│ │ │ ├── authorization_manager.go
│ │ │ ├── authorization_manager_internal.go
│ │ │ ├── cluster_compute_resource.go
│ │ │ ├── cluster_compute_resource_test.go
│ │ │ ├── common.go
│ │ │ ├── common_test.go
│ │ │ ├── compute_resource.go
│ │ │ ├── compute_resource_test.go
│ │ │ ├── custom_fields_manager.go
│ │ │ ├── customization_spec_manager.go
│ │ │ ├── datacenter.go
│ │ │ ├── datacenter_test.go
│ │ │ ├── datastore.go
│ │ │ ├── datastore_file.go
│ │ │ ├── datastore_file_manager.go
│ │ │ ├── datastore_path.go
│ │ │ ├── datastore_path_test.go
│ │ │ ├── datastore_test.go
│ │ │ ├── diagnostic_log.go
│ │ │ ├── diagnostic_manager.go
│ │ │ ├── distributed_virtual_portgroup.go
│ │ │ ├── distributed_virtual_portgroup_test.go
│ │ │ ├── distributed_virtual_switch.go
│ │ │ ├── extension_manager.go
│ │ │ ├── file_manager.go
│ │ │ ├── folder.go
│ │ │ ├── folder_test.go
│ │ │ ├── history_collector.go
│ │ │ ├── host_account_manager.go
│ │ │ ├── host_certificate_info.go
│ │ │ ├── host_certificate_info_test.go
│ │ │ ├── host_certificate_manager.go
│ │ │ ├── host_config_manager.go
│ │ │ ├── host_datastore_browser.go
│ │ │ ├── host_datastore_system.go
│ │ │ ├── host_date_time_system.go
│ │ │ ├── host_firewall_system.go
│ │ │ ├── host_network_system.go
│ │ │ ├── host_service_system.go
│ │ │ ├── host_storage_system.go
│ │ │ ├── host_system.go
│ │ │ ├── host_virtual_nic_manager.go
│ │ │ ├── host_vsan_internal_system.go
│ │ │ ├── host_vsan_system.go
│ │ │ ├── http_nfc_lease.go
│ │ │ ├── namespace_manager.go
│ │ │ ├── network.go
│ │ │ ├── network_reference.go
│ │ │ ├── network_test.go
│ │ │ ├── opaque_network.go
│ │ │ ├── option_manager.go
│ │ │ ├── ovf_manager.go
│ │ │ ├── resource_pool.go
│ │ │ ├── search_index.go
│ │ │ ├── search_index_test.go
│ │ │ ├── storage_pod.go
│ │ │ ├── storage_resource_manager.go
│ │ │ ├── task.go
│ │ │ ├── types.go
│ │ │ ├── virtual_app.go
│ │ │ ├── virtual_device_list.go
│ │ │ ├── virtual_device_list_test.go
│ │ │ ├── virtual_disk_manager.go
│ │ │ ├── virtual_disk_manager_internal.go
│ │ │ ├── virtual_machine.go
│ │ │ ├── virtual_machine_test.go
│ │ │ └── vmware_distributed_virtual_switch.go
│ │ ├── ovf/
│ │ │ ├── cim.go
│ │ │ ├── doc.go
│ │ │ ├── env.go
│ │ │ ├── env_test.go
│ │ │ ├── envelope.go
│ │ │ ├── ovf.go
│ │ │ └── ovf_test.go
│ │ ├── pbm/
│ │ │ ├── client.go
│ │ │ ├── client_test.go
│ │ │ ├── methods/
│ │ │ │ └── methods.go
│ │ │ ├── pbm_util.go
│ │ │ └── types/
│ │ │ ├── enum.go
│ │ │ ├── if.go
│ │ │ └── types.go
│ │ ├── performance/
│ │ │ └── manager.go
│ │ ├── property/
│ │ │ ├── collector.go
│ │ │ ├── filter.go
│ │ │ ├── filter_test.go
│ │ │ └── wait.go
│ │ ├── scripts/
│ │ │ ├── .gitignore
│ │ │ ├── contributors.sh
│ │ │ ├── debug-ls.sh
│ │ │ ├── debug-xmlformat.sh
│ │ │ ├── govc-env.bash
│ │ │ ├── govc_bash_completion
│ │ │ ├── headers/
│ │ │ │ ├── go.txt
│ │ │ │ └── rb.txt
│ │ │ ├── license.sh
│ │ │ ├── vagrant/
│ │ │ │ └── vcsa/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── Vagrantfile
│ │ │ │ ├── create-box.sh
│ │ │ │ └── vagrant.sh
│ │ │ ├── wireshark-esx.sh
│ │ │ └── wireshark-vcsa.sh
│ │ ├── session/
│ │ │ ├── keep_alive.go
│ │ │ ├── keep_alive_test.go
│ │ │ ├── manager.go
│ │ │ └── manager_test.go
│ │ ├── task/
│ │ │ ├── error.go
│ │ │ ├── wait.go
│ │ │ └── wait_test.go
│ │ ├── test/
│ │ │ ├── doc.go
│ │ │ ├── functional/
│ │ │ │ ├── helper.go
│ │ │ │ └── issue_242_test.go
│ │ │ └── helper.go
│ │ ├── units/
│ │ │ ├── size.go
│ │ │ └── size_test.go
│ │ ├── view/
│ │ │ ├── container_view.go
│ │ │ ├── list_view.go
│ │ │ └── manager.go
│ │ └── vim25/
│ │ ├── client.go
│ │ ├── client_test.go
│ │ ├── debug/
│ │ │ └── debug.go
│ │ ├── doc.go
│ │ ├── methods/
│ │ │ ├── fault_test.go
│ │ │ ├── internal.go
│ │ │ ├── methods.go
│ │ │ └── service_content.go
│ │ ├── mo/
│ │ │ ├── ancestors.go
│ │ │ ├── entity.go
│ │ │ ├── extra.go
│ │ │ ├── fixtures/
│ │ │ │ ├── cluster_host_property.xml
│ │ │ │ ├── hostsystem_list_name_property.xml
│ │ │ │ ├── nested_property.xml
│ │ │ │ ├── not_authenticated_fault.xml
│ │ │ │ └── pointer_property.xml
│ │ │ ├── mo.go
│ │ │ ├── reference.go
│ │ │ ├── registry.go
│ │ │ ├── retrieve.go
│ │ │ ├── retrieve_test.go
│ │ │ ├── type_info.go
│ │ │ └── type_info_test.go
│ │ ├── progress/
│ │ │ ├── aggregator.go
│ │ │ ├── aggregator_test.go
│ │ │ ├── common_test.go
│ │ │ ├── doc.go
│ │ │ ├── prefix.go
│ │ │ ├── prefix_test.go
│ │ │ ├── reader.go
│ │ │ ├── reader_test.go
│ │ │ ├── report.go
│ │ │ ├── scale.go
│ │ │ ├── scale_test.go
│ │ │ ├── sinker.go
│ │ │ ├── tee.go
│ │ │ └── tee_test.go
│ │ ├── retry.go
│ │ ├── retry_test.go
│ │ ├── soap/
│ │ │ ├── client.go
│ │ │ ├── client_test.go
│ │ │ ├── debug.go
│ │ │ ├── error.go
│ │ │ ├── soap.go
│ │ │ └── soap_test.go
│ │ ├── types/
│ │ │ ├── base.go
│ │ │ ├── base_test.go
│ │ │ ├── enum.go
│ │ │ ├── fault.go
│ │ │ ├── helpers.go
│ │ │ ├── if.go
│ │ │ ├── internal.go
│ │ │ ├── registry.go
│ │ │ ├── registry_test.go
│ │ │ ├── types.go
│ │ │ └── types_test.go
│ │ └── xml/
│ │ ├── LICENSE
│ │ ├── atom_test.go
│ │ ├── example_test.go
│ │ ├── extras.go
│ │ ├── extras_test.go
│ │ ├── marshal.go
│ │ ├── marshal_test.go
│ │ ├── read.go
│ │ ├── read_test.go
│ │ ├── typeinfo.go
│ │ ├── xml.go
│ │ └── xml_test.go
│ └── golang.org/
│ └── x/
│ └── net/
│ ├── .gitattributes
│ ├── .gitignore
│ ├── AUTHORS
│ ├── CONTRIBUTING.md
│ ├── CONTRIBUTORS
│ ├── LICENSE
│ ├── PATENTS
│ ├── README.md
│ ├── bpf/
│ │ ├── asm.go
│ │ ├── constants.go
│ │ ├── doc.go
│ │ ├── instructions.go
│ │ ├── instructions_test.go
│ │ ├── setter.go
│ │ ├── testdata/
│ │ │ ├── all_instructions.bpf
│ │ │ └── all_instructions.txt
│ │ ├── vm.go
│ │ ├── vm_aluop_test.go
│ │ ├── vm_bpf_test.go
│ │ ├── vm_extension_test.go
│ │ ├── vm_instructions.go
│ │ ├── vm_jump_test.go
│ │ ├── vm_load_test.go
│ │ ├── vm_ret_test.go
│ │ ├── vm_scratch_test.go
│ │ └── vm_test.go
│ ├── codereview.cfg
│ ├── context/
│ │ ├── context.go
│ │ ├── context_test.go
│ │ ├── ctxhttp/
│ │ │ ├── ctxhttp.go
│ │ │ ├── ctxhttp_17_test.go
│ │ │ ├── ctxhttp_pre17.go
│ │ │ ├── ctxhttp_pre17_test.go
│ │ │ └── ctxhttp_test.go
│ │ ├── go17.go
│ │ ├── go19.go
│ │ ├── pre_go17.go
│ │ ├── pre_go19.go
│ │ └── withtimeout_test.go
│ ├── dict/
│ │ └── dict.go
│ ├── dns/
│ │ └── dnsmessage/
│ │ ├── example_test.go
│ │ ├── message.go
│ │ └── message_test.go
│ ├── html/
│ │ ├── atom/
│ │ │ ├── atom.go
│ │ │ ├── atom_test.go
│ │ │ ├── gen.go
│ │ │ ├── table.go
│ │ │ └── table_test.go
│ │ ├── charset/
│ │ │ ├── charset.go
│ │ │ ├── charset_test.go
│ │ │ └── testdata/
│ │ │ ├── HTTP-charset.html
│ │ │ ├── HTTP-vs-UTF-8-BOM.html
│ │ │ ├── HTTP-vs-meta-charset.html
│ │ │ ├── HTTP-vs-meta-content.html
│ │ │ ├── No-encoding-declaration.html
│ │ │ ├── README
│ │ │ ├── UTF-16BE-BOM.html
│ │ │ ├── UTF-16LE-BOM.html
│ │ │ ├── UTF-8-BOM-vs-meta-charset.html
│ │ │ ├── UTF-8-BOM-vs-meta-content.html
│ │ │ ├── meta-charset-attribute.html
│ │ │ └── meta-content-attribute.html
│ │ ├── const.go
│ │ ├── doc.go
│ │ ├── doctype.go
│ │ ├── entity.go
│ │ ├── entity_test.go
│ │ ├── escape.go
│ │ ├── escape_test.go
│ │ ├── example_test.go
│ │ ├── foreign.go
│ │ ├── node.go
│ │ ├── node_test.go
│ │ ├── parse.go
│ │ ├── parse_test.go
│ │ ├── render.go
│ │ ├── render_test.go
│ │ ├── testdata/
│ │ │ ├── go1.html
│ │ │ └── webkit/
│ │ │ └── README
│ │ ├── token.go
│ │ └── token_test.go
│ ├── http2/
│ │ ├── .gitignore
│ │ ├── Dockerfile
│ │ ├── Makefile
│ │ ├── README
│ │ ├── ciphers.go
│ │ ├── ciphers_test.go
│ │ ├── client_conn_pool.go
│ │ ├── configure_transport.go
│ │ ├── databuffer.go
│ │ ├── databuffer_test.go
│ │ ├── errors.go
│ │ ├── errors_test.go
│ │ ├── flow.go
│ │ ├── flow_test.go
│ │ ├── frame.go
│ │ ├── frame_test.go
│ │ ├── go16.go
│ │ ├── go17.go
│ │ ├── go17_not18.go
│ │ ├── go18.go
│ │ ├── go18_test.go
│ │ ├── go19.go
│ │ ├── go19_test.go
│ │ ├── gotrack.go
│ │ ├── gotrack_test.go
│ │ ├── h2i/
│ │ │ ├── README.md
│ │ │ └── h2i.go
│ │ ├── headermap.go
│ │ ├── hpack/
│ │ │ ├── encode.go
│ │ │ ├── encode_test.go
│ │ │ ├── hpack.go
│ │ │ ├── hpack_test.go
│ │ │ ├── huffman.go
│ │ │ ├── tables.go
│ │ │ └── tables_test.go
│ │ ├── http2.go
│ │ ├── http2_test.go
│ │ ├── not_go16.go
│ │ ├── not_go17.go
│ │ ├── not_go18.go
│ │ ├── not_go19.go
│ │ ├── pipe.go
│ │ ├── pipe_test.go
│ │ ├── server.go
│ │ ├── server_push_test.go
│ │ ├── server_test.go
│ │ ├── testdata/
│ │ │ └── draft-ietf-httpbis-http2.xml
│ │ ├── transport.go
│ │ ├── transport_test.go
│ │ ├── write.go
│ │ ├── writesched.go
│ │ ├── writesched_priority.go
│ │ ├── writesched_priority_test.go
│ │ ├── writesched_random.go
│ │ ├── writesched_random_test.go
│ │ ├── writesched_test.go
│ │ └── z_spec_test.go
│ ├── icmp/
│ │ ├── dstunreach.go
│ │ ├── echo.go
│ │ ├── endpoint.go
│ │ ├── example_test.go
│ │ ├── extension.go
│ │ ├── extension_test.go
│ │ ├── helper_posix.go
│ │ ├── interface.go
│ │ ├── ipv4.go
│ │ ├── ipv4_test.go
│ │ ├── ipv6.go
│ │ ├── listen_posix.go
│ │ ├── listen_stub.go
│ │ ├── message.go
│ │ ├── message_test.go
│ │ ├── messagebody.go
│ │ ├── mpls.go
│ │ ├── multipart.go
│ │ ├── multipart_test.go
│ │ ├── packettoobig.go
│ │ ├── paramprob.go
│ │ ├── ping_test.go
│ │ ├── sys_freebsd.go
│ │ └── timeexceeded.go
│ ├── idna/
│ │ ├── example_test.go
│ │ ├── idna.go
│ │ ├── idna_test.go
│ │ ├── punycode.go
│ │ ├── punycode_test.go
│ │ ├── tables.go
│ │ ├── trie.go
│ │ └── trieval.go
│ ├── internal/
│ │ ├── iana/
│ │ │ ├── const.go
│ │ │ └── gen.go
│ │ ├── nettest/
│ │ │ ├── helper_bsd.go
│ │ │ ├── helper_nobsd.go
│ │ │ ├── helper_posix.go
│ │ │ ├── helper_stub.go
│ │ │ ├── helper_unix.go
│ │ │ ├── helper_windows.go
│ │ │ ├── interface.go
│ │ │ ├── rlimit.go
│ │ │ └── stack.go
│ │ ├── socket/
│ │ │ ├── cmsghdr.go
│ │ │ ├── cmsghdr_bsd.go
│ │ │ ├── cmsghdr_linux_32bit.go
│ │ │ ├── cmsghdr_linux_64bit.go
│ │ │ ├── cmsghdr_solaris_64bit.go
│ │ │ ├── cmsghdr_stub.go
│ │ │ ├── defs_darwin.go
│ │ │ ├── defs_dragonfly.go
│ │ │ ├── defs_freebsd.go
│ │ │ ├── defs_linux.go
│ │ │ ├── defs_netbsd.go
│ │ │ ├── defs_openbsd.go
│ │ │ ├── defs_solaris.go
│ │ │ ├── error_unix.go
│ │ │ ├── error_windows.go
│ │ │ ├── iovec_32bit.go
│ │ │ ├── iovec_64bit.go
│ │ │ ├── iovec_solaris_64bit.go
│ │ │ ├── iovec_stub.go
│ │ │ ├── mmsghdr_stub.go
│ │ │ ├── mmsghdr_unix.go
│ │ │ ├── msghdr_bsd.go
│ │ │ ├── msghdr_bsdvar.go
│ │ │ ├── msghdr_linux.go
│ │ │ ├── msghdr_linux_32bit.go
│ │ │ ├── msghdr_linux_64bit.go
│ │ │ ├── msghdr_openbsd.go
│ │ │ ├── msghdr_solaris_64bit.go
│ │ │ ├── msghdr_stub.go
│ │ │ ├── rawconn.go
│ │ │ ├── rawconn_mmsg.go
│ │ │ ├── rawconn_msg.go
│ │ │ ├── rawconn_nommsg.go
│ │ │ ├── rawconn_nomsg.go
│ │ │ ├── rawconn_stub.go
│ │ │ ├── reflect.go
│ │ │ ├── socket.go
│ │ │ ├── socket_go1_9_test.go
│ │ │ ├── socket_test.go
│ │ │ ├── sys.go
│ │ │ ├── sys_bsd.go
│ │ │ ├── sys_bsdvar.go
│ │ │ ├── sys_darwin.go
│ │ │ ├── sys_dragonfly.go
│ │ │ ├── sys_linux.go
│ │ │ ├── sys_linux_386.go
│ │ │ ├── sys_linux_386.s
│ │ │ ├── sys_linux_amd64.go
│ │ │ ├── sys_linux_arm.go
│ │ │ ├── sys_linux_arm64.go
│ │ │ ├── sys_linux_mips.go
│ │ │ ├── sys_linux_mips64.go
│ │ │ ├── sys_linux_mips64le.go
│ │ │ ├── sys_linux_mipsle.go
│ │ │ ├── sys_linux_ppc64.go
│ │ │ ├── sys_linux_ppc64le.go
│ │ │ ├── sys_linux_s390x.go
│ │ │ ├── sys_linux_s390x.s
│ │ │ ├── sys_netbsd.go
│ │ │ ├── sys_posix.go
│ │ │ ├── sys_solaris.go
│ │ │ ├── sys_solaris_amd64.s
│ │ │ ├── sys_stub.go
│ │ │ ├── sys_unix.go
│ │ │ ├── sys_windows.go
│ │ │ ├── zsys_darwin_386.go
│ │ │ ├── zsys_darwin_amd64.go
│ │ │ ├── zsys_darwin_arm.go
│ │ │ ├── zsys_dragonfly_amd64.go
│ │ │ ├── zsys_freebsd_386.go
│ │ │ ├── zsys_freebsd_amd64.go
│ │ │ ├── zsys_freebsd_arm.go
│ │ │ ├── zsys_linux_386.go
│ │ │ ├── zsys_linux_amd64.go
│ │ │ ├── zsys_linux_arm.go
│ │ │ ├── zsys_linux_arm64.go
│ │ │ ├── zsys_linux_mips.go
│ │ │ ├── zsys_linux_mips64.go
│ │ │ ├── zsys_linux_mips64le.go
│ │ │ ├── zsys_linux_mipsle.go
│ │ │ ├── zsys_linux_ppc64.go
│ │ │ ├── zsys_linux_ppc64le.go
│ │ │ ├── zsys_linux_s390x.go
│ │ │ ├── zsys_netbsd_386.go
│ │ │ ├── zsys_netbsd_amd64.go
│ │ │ ├── zsys_netbsd_arm.go
│ │ │ ├── zsys_openbsd_386.go
│ │ │ ├── zsys_openbsd_amd64.go
│ │ │ ├── zsys_openbsd_arm.go
│ │ │ └── zsys_solaris_amd64.go
│ │ └── timeseries/
│ │ ├── timeseries.go
│ │ └── timeseries_test.go
│ ├── ipv4/
│ │ ├── batch.go
│ │ ├── bpf_test.go
│ │ ├── control.go
│ │ ├── control_bsd.go
│ │ ├── control_pktinfo.go
│ │ ├── control_stub.go
│ │ ├── control_test.go
│ │ ├── control_unix.go
│ │ ├── control_windows.go
│ │ ├── defs_darwin.go
│ │ ├── defs_dragonfly.go
│ │ ├── defs_freebsd.go
│ │ ├── defs_linux.go
│ │ ├── defs_netbsd.go
│ │ ├── defs_openbsd.go
│ │ ├── defs_solaris.go
│ │ ├── dgramopt.go
│ │ ├── doc.go
│ │ ├── endpoint.go
│ │ ├── example_test.go
│ │ ├── gen.go
│ │ ├── genericopt.go
│ │ ├── header.go
│ │ ├── header_test.go
│ │ ├── helper.go
│ │ ├── iana.go
│ │ ├── icmp.go
│ │ ├── icmp_linux.go
│ │ ├── icmp_stub.go
│ │ ├── icmp_test.go
│ │ ├── multicast_test.go
│ │ ├── multicastlistener_test.go
│ │ ├── multicastsockopt_test.go
│ │ ├── packet.go
│ │ ├── packet_go1_8.go
│ │ ├── packet_go1_9.go
│ │ ├── payload.go
│ │ ├── payload_cmsg.go
│ │ ├── payload_cmsg_go1_8.go
│ │ ├── payload_cmsg_go1_9.go
│ │ ├── payload_nocmsg.go
│ │ ├── readwrite_go1_8_test.go
│ │ ├── readwrite_go1_9_test.go
│ │ ├── readwrite_test.go
│ │ ├── sockopt.go
│ │ ├── sockopt_posix.go
│ │ ├── sockopt_stub.go
│ │ ├── sys_asmreq.go
│ │ ├── sys_asmreq_stub.go
│ │ ├── sys_asmreqn.go
│ │ ├── sys_asmreqn_stub.go
│ │ ├── sys_bpf.go
│ │ ├── sys_bpf_stub.go
│ │ ├── sys_bsd.go
│ │ ├── sys_darwin.go
│ │ ├── sys_dragonfly.go
│ │ ├── sys_freebsd.go
│ │ ├── sys_linux.go
│ │ ├── sys_solaris.go
│ │ ├── sys_ssmreq.go
│ │ ├── sys_ssmreq_stub.go
│ │ ├── sys_stub.go
│ │ ├── sys_windows.go
│ │ ├── unicast_test.go
│ │ ├── unicastsockopt_test.go
│ │ ├── zsys_darwin.go
│ │ ├── zsys_dragonfly.go
│ │ ├── zsys_freebsd_386.go
│ │ ├── zsys_freebsd_amd64.go
│ │ ├── zsys_freebsd_arm.go
│ │ ├── zsys_linux_386.go
│ │ ├── zsys_linux_amd64.go
│ │ ├── zsys_linux_arm.go
│ │ ├── zsys_linux_arm64.go
│ │ ├── zsys_linux_mips.go
│ │ ├── zsys_linux_mips64.go
│ │ ├── zsys_linux_mips64le.go
│ │ ├── zsys_linux_mipsle.go
│ │ ├── zsys_linux_ppc.go
│ │ ├── zsys_linux_ppc64.go
│ │ ├── zsys_linux_ppc64le.go
│ │ ├── zsys_linux_s390x.go
│ │ ├── zsys_netbsd.go
│ │ ├── zsys_openbsd.go
│ │ └── zsys_solaris.go
│ ├── ipv6/
│ │ ├── batch.go
│ │ ├── bpf_test.go
│ │ ├── control.go
│ │ ├── control_rfc2292_unix.go
│ │ ├── control_rfc3542_unix.go
│ │ ├── control_stub.go
│ │ ├── control_test.go
│ │ ├── control_unix.go
│ │ ├── control_windows.go
│ │ ├── defs_darwin.go
│ │ ├── defs_dragonfly.go
│ │ ├── defs_freebsd.go
│ │ ├── defs_linux.go
│ │ ├── defs_netbsd.go
│ │ ├── defs_openbsd.go
│ │ ├── defs_solaris.go
│ │ ├── dgramopt.go
│ │ ├── doc.go
│ │ ├── endpoint.go
│ │ ├── example_test.go
│ │ ├── gen.go
│ │ ├── genericopt.go
│ │ ├── header.go
│ │ ├── header_test.go
│ │ ├── helper.go
│ │ ├── iana.go
│ │ ├── icmp.go
│ │ ├── icmp_bsd.go
│ │ ├── icmp_linux.go
│ │ ├── icmp_solaris.go
│ │ ├── icmp_stub.go
│ │ ├── icmp_test.go
│ │ ├── icmp_windows.go
│ │ ├── mocktransponder_test.go
│ │ ├── multicast_test.go
│ │ ├── multicastlistener_test.go
│ │ ├── multicastsockopt_test.go
│ │ ├── payload.go
│ │ ├── payload_cmsg.go
│ │ ├── payload_cmsg_go1_8.go
│ │ ├── payload_cmsg_go1_9.go
│ │ ├── payload_nocmsg.go
│ │ ├── readwrite_go1_8_test.go
│ │ ├── readwrite_go1_9_test.go
│ │ ├── readwrite_test.go
│ │ ├── sockopt.go
│ │ ├── sockopt_posix.go
│ │ ├── sockopt_stub.go
│ │ ├── sockopt_test.go
│ │ ├── sys_asmreq.go
│ │ ├── sys_asmreq_stub.go
│ │ ├── sys_bpf.go
│ │ ├── sys_bpf_stub.go
│ │ ├── sys_bsd.go
│ │ ├── sys_darwin.go
│ │ ├── sys_freebsd.go
│ │ ├── sys_linux.go
│ │ ├── sys_solaris.go
│ │ ├── sys_ssmreq.go
│ │ ├── sys_ssmreq_stub.go
│ │ ├── sys_stub.go
│ │ ├── sys_windows.go
│ │ ├── unicast_test.go
│ │ ├── unicastsockopt_test.go
│ │ ├── zsys_darwin.go
│ │ ├── zsys_dragonfly.go
│ │ ├── zsys_freebsd_386.go
│ │ ├── zsys_freebsd_amd64.go
│ │ ├── zsys_freebsd_arm.go
│ │ ├── zsys_linux_386.go
│ │ ├── zsys_linux_amd64.go
│ │ ├── zsys_linux_arm.go
│ │ ├── zsys_linux_arm64.go
│ │ ├── zsys_linux_mips.go
│ │ ├── zsys_linux_mips64.go
│ │ ├── zsys_linux_mips64le.go
│ │ ├── zsys_linux_mipsle.go
│ │ ├── zsys_linux_ppc.go
│ │ ├── zsys_linux_ppc64.go
│ │ ├── zsys_linux_ppc64le.go
│ │ ├── zsys_linux_s390x.go
│ │ ├── zsys_netbsd.go
│ │ ├── zsys_openbsd.go
│ │ └── zsys_solaris.go
│ ├── lex/
│ │ └── httplex/
│ │ ├── httplex.go
│ │ └── httplex_test.go
│ ├── lif/
│ │ ├── address.go
│ │ ├── address_test.go
│ │ ├── binary.go
│ │ ├── defs_solaris.go
│ │ ├── lif.go
│ │ ├── link.go
│ │ ├── link_test.go
│ │ ├── sys.go
│ │ ├── sys_solaris_amd64.s
│ │ ├── syscall.go
│ │ └── zsys_solaris_amd64.go
│ ├── nettest/
│ │ ├── conntest.go
│ │ ├── conntest_go16.go
│ │ ├── conntest_go17.go
│ │ └── conntest_test.go
│ ├── netutil/
│ │ ├── listen.go
│ │ └── listen_test.go
│ ├── proxy/
│ │ ├── direct.go
│ │ ├── per_host.go
│ │ ├── per_host_test.go
│ │ ├── proxy.go
│ │ ├── proxy_test.go
│ │ └── socks5.go
│ ├── publicsuffix/
│ │ ├── gen.go
│ │ ├── list.go
│ │ ├── list_test.go
│ │ ├── table.go
│ │ └── table_test.go
│ ├── route/
│ │ ├── address.go
│ │ ├── address_darwin_test.go
│ │ ├── address_test.go
│ │ ├── binary.go
│ │ ├── defs_darwin.go
│ │ ├── defs_dragonfly.go
│ │ ├── defs_freebsd.go
│ │ ├── defs_netbsd.go
│ │ ├── defs_openbsd.go
│ │ ├── interface.go
│ │ ├── interface_announce.go
│ │ ├── interface_classic.go
│ │ ├── interface_freebsd.go
│ │ ├── interface_multicast.go
│ │ ├── interface_openbsd.go
│ │ ├── message.go
│ │ ├── message_darwin_test.go
│ │ ├── message_freebsd_test.go
│ │ ├── message_test.go
│ │ ├── route.go
│ │ ├── route_classic.go
│ │ ├── route_openbsd.go
│ │ ├── route_test.go
│ │ ├── sys.go
│ │ ├── sys_darwin.go
│ │ ├── sys_dragonfly.go
│ │ ├── sys_freebsd.go
│ │ ├── sys_netbsd.go
│ │ ├── sys_openbsd.go
│ │ ├── syscall.go
│ │ ├── zsys_darwin.go
│ │ ├── zsys_dragonfly.go
│ │ ├── zsys_freebsd_386.go
│ │ ├── zsys_freebsd_amd64.go
│ │ ├── zsys_freebsd_arm.go
│ │ ├── zsys_netbsd.go
│ │ └── zsys_openbsd.go
│ ├── trace/
│ │ ├── events.go
│ │ ├── histogram.go
│ │ ├── histogram_test.go
│ │ ├── trace.go
│ │ ├── trace_go16.go
│ │ ├── trace_go17.go
│ │ └── trace_test.go
│ ├── webdav/
│ │ ├── file.go
│ │ ├── file_go1.6.go
│ │ ├── file_go1.7.go
│ │ ├── file_test.go
│ │ ├── if.go
│ │ ├── if_test.go
│ │ ├── internal/
│ │ │ └── xml/
│ │ │ ├── README
│ │ │ ├── atom_test.go
│ │ │ ├── example_test.go
│ │ │ ├── marshal.go
│ │ │ ├── marshal_test.go
│ │ │ ├── read.go
│ │ │ ├── read_test.go
│ │ │ ├── typeinfo.go
│ │ │ ├── xml.go
│ │ │ └── xml_test.go
│ │ ├── litmus_test_server.go
│ │ ├── lock.go
│ │ ├── lock_test.go
│ │ ├── prop.go
│ │ ├── prop_test.go
│ │ ├── webdav.go
│ │ ├── webdav_test.go
│ │ ├── xml.go
│ │ └── xml_test.go
│ ├── websocket/
│ │ ├── client.go
│ │ ├── dial.go
│ │ ├── dial_test.go
│ │ ├── exampledial_test.go
│ │ ├── examplehandler_test.go
│ │ ├── hybi.go
│ │ ├── hybi_test.go
│ │ ├── server.go
│ │ ├── websocket.go
│ │ └── websocket_test.go
│ └── xsrftoken/
│ ├── xsrf.go
│ └── xsrf_test.go
├── vsphere-influxdb.go
└── vsphere-influxdb.json.sample
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
### Basic ignore file
# Binaries for programs and plugins
vsphere-influxdb
# Test binary, build with `go test -c`
*.test
# Output of the go coverage tool, specifically when used with LiteIDE
*.out
# Configuration file
vsphere-influxdb.json
# Vim swap files
*.swp
================================================
FILE: .travis.yml
================================================
language: go
sudo: required
go:
- 1.9
env:
- PATH=/home/travis/gopath/bin:$PATH
before_install:
- sudo apt-get -qq update
- sudo apt-get install -y ruby ruby-dev build-essential rpm
- go get -u github.com/golang/dep/cmd/dep
- go get -u github.com/alecthomas/gometalinter
install:
- dep ensure
before_script:
- gometalinter --install
# - gometalinter --vendor ./...
script:
- git status
after_success:
# - gem install --no-ri --no-rdoc fpm
- test -n "$TRAVIS_TAG" && curl -sL https://git.io/goreleaser | bash
================================================
FILE: Dockerfile
================================================
FROM golang:1.12-alpine3.10 as builder
WORKDIR /go/src/vsphere-influxdb-go
COPY . .
RUN apk --update add --virtual build-deps git
RUN go get -d -v ./...
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo
FROM alpine:3.10
RUN apk update \
&& apk upgrade \
&& apk add ca-certificates \
&& addgroup -S spock && adduser -S spock -G spock
COPY --from=0 /go/src/vsphere-influxdb-go/vsphere-influxdb-go /vsphere-influxdb-go
USER spock
CMD ["/vsphere-influxdb-go"]
================================================
FILE: Gopkg.toml
================================================
# Gopkg.toml example
#
# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
# for detailed Gopkg.toml documentation.
#
# required = ["github.com/user/thing/cmd/thing"]
# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
#
# [[constraint]]
# name = "github.com/user/project"
# version = "1.0.0"
#
# [[constraint]]
# name = "github.com/user/project2"
# branch = "dev"
# source = "github.com/myfork/project2"
#
# [[override]]
# name = "github.com/x/y"
# version = "2.4.0"
[[constraint]]
name = "github.com/davecgh/go-spew"
version = "1.1.0"
[[constraint]]
name = "github.com/influxdata/influxdb"
version = "1.3.6"
[[constraint]]
name = "github.com/vmware/govmomi"
version = "0.15.0"
[[constraint]]
branch = "master"
name = "golang.org/x/net"
================================================
FILE: LICENSE.txt
================================================
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
================================================
FILE: README.md
================================================
[](https://github.com/Oxalide/vsphere-influxdb-go/releases/latest) [](https://travis-ci.org/Oxalide/vsphere-influxdb-go) [](https://goreportcard.com/report/github.com/Oxalide/vsphere-influxdb-go)
# Collect VMware vCenter and ESXi performance metrics and send them to InfluxDB
# Screenshots of Grafana dashboards
# Description and Features
This is a tool written in Go that helps you do your own custom tailored monitoring, capacity planning and performance debugging of VMware based infrastructures. It collects all possible metrics from vCenters and ESXi hypervisors about hosts, clusters, resource pools, datastores and virtual machines and sends them to an [InfluxDB database](https://github.com/influxdata/influxdb) (a popular open source time series database project written in Go), which you can then visualise in Grafana (links to sample dashboards [below](#example-dashboards)) or Chronograf, and use Grafana, Kapacitor or custom scripts to do alerting based on your needs, KPIs, capacity plannings/expectations.
# Install
Grab the [latest release](https://github.com/Oxalide/vsphere-influxdb-go/releases/latest) for your OS (deb, rpm packages, exes, archives for Linux, Darwin, Windows, FreeBSD on amd64, arm6, arm7, arm64 are available) and install it.
For Debian/Ubuntu on adm64:
```
curl -L -O $(curl -s https://api.github.com/repos/Oxalide/vsphere-influxdb-go/releases | grep browser_download_url | grep '64[.]deb' | head -n 1 | cut -d '"' -f 4)
dpkg -i vsphere-influxdb-go*.deb
```
CentOS/Red Hat on amd64:
```
curl -L -O $(curl -s https://api.github.com/repos/Oxalide/vsphere-influxdb-go/releases | grep browser_download_url | grep '64[.]rpm' | head -n 1 | cut -d '"' -f 4)
rpm -i vsphere-influxdb-go*.rpm
```
This will install vsphere-influxdb-go in /usr/local/bin/vsphere-influxdb-go and an example configuration file in /etc/vsphere-influxdb-go.json that needs to be edited.
# Configure
The JSON configuration file in /etc/vsphere-influxdb-go.json contains all your vCenters/ESXi to connect to, the InfluxDB connection details(url, username/password, database to use), and the metrics to collect(full list [here](http://www.virten.net/2015/05/vsphere-6-0-performance-counter-description/) ).
**Note: Not all metrics are available directly, you might need to change your metric collection level.**
A table with the level needed for each metric is availble [here](http://www.virten.net/2015/05/which-performance-counters-are-available-in-each-statistic-level/), and you can find a python script to change the collect level in the [tools folder of the project](./tools/).
Additionally you can provide a vCenter/ESXi server and InfluxDB connection details via environment variables, wich is extremly helpful when running inside a container:
For InfluxDB:
* INFLUX\_HOSTNAME
* INFLUX\_USERNAME
* INFLUX\_PASSWORD
* INFLUX\_DATABASE
For vSphere:
* VSPHERE\_HOSTNAME
* VSPHERE\_USERNAME
* VSPHERE\_PASSWORD
Keep in mind, that currently only one vCenter/ESXi can be added via environment variable.
If you set a domain, it will be automaticaly removed from the names of the found objects.
Metrics collected are defined by associating ObjectType groups with Metric groups.
There have been reports of the script not working correctly when the time is incorrect on the vsphere or vcenter. Make sure that the time is valid or activate the NTP service on the machine.
# Run as a service
Create a crontab to run it every X minutes(one minute is fine - in our case, ~30 vCenters, ~100 ESXi and ~1400 VMs take approximately 25s to collect all metrics - rather impressive, i might add).
```
* * * * * /usr/local/bin/vsphere-influxdb-go
```
# Example dashboards
* https://grafana.com/dashboards/1299 (thanks to @exbane )
* https://grafana.com/dashboards/3556 (VMware cloud overview, mostly provisioning/global cloud usage stats)
* https://grafana.com/dashboards/3571 (VMware performance, mostly VM oriented performance stats)
Contributions welcome!
# Compile from source
```
go get github.com/oxalide/vsphere-influxdb-go
```
This will install the project in your $GOBIN($GOPATH/bin). If you have appended $GOBIN to your $PATH, you will be able to call it directly. Otherwise, you'll have to call it with its full path.
Example:
```
vsphere-influxdb-go
```
or :
```
$GOBIN/vsphere-influxdb-go
```
# TODO before v1.0
* Add service discovery(or probably something like [Viper](https://github.com/spf13/viper) for easier and more flexible configuration with multiple backends)
* Daemonize
* Provide a ready to use Dockerfile
# Contributing
You are welcome to contribute!
# License
The original project, upon which this one is based, is written by cblomart, sends the data to Graphite, and is available [here](https://github.com/cblomart/vsphere-graphite).
This one is licensed under GPLv3. You can find a copy of the license in [LICENSE.txt](./LICENSE.txt)
================================================
FILE: goreleaser.yml
================================================
project_name: vsphere-influxdb-go
builds:
- binary: vsphere-influxdb-go
goos:
- windows
- darwin
- linux
- freebsd
goarch:
- amd64
- arm
- arm64
goarm:
- 6
- 7
archive:
format: tar.gz
files:
- LICENSE.txt
- README.md
nfpm:
# Your app's vendor.
# Default is empty.
vendor: Oxalide
# Your app's homepage.
homepage: https://github.com/Oxalide/vsphere-influxdb-go
# Your app's maintainer (probably you).
maintainer: Adrian Todorov <ato@oxalide.com>
# Your app's description.
description: Collect VMware vSphere, vCenter and ESXi performance metrics and send them to InfluxDB
# Your app's license.
license: GPL 3.0
# Formats to be generated.
formats:
- deb
- rpm
# Files or directories to add to your package (beyond the binary).
# Keys are source paths to get the files from.
# Values are the destination locations of the files in the package.
files:
"vsphere-influxdb.json.sample": "/etc/vsphere-influxdb-go.json"
================================================
FILE: tools/README.md
================================================
# Change vCenter metric collection level
```
git clone https://github.com/Oxalide/vsphere-influxdb-go.git
pip install -r tools/requirements.txt
./tools/change_metric_collection_level.py
```
================================================
FILE: tools/change_metric_collection_level.py
================================================
#!/usr/bin/python
#============================================
# Script: change_metric_collection_level.py
# Description: Change the metric collection level of an interval in a vCenter
# Copyright 2017 Adrian Todorov, Oxalide ato@oxalide.com
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#============================================
from pyVim.connect import SmartConnect, Disconnect
from pyVmomi import vim
import atexit
import sys
import requests
import argparse
import getpass
import linecache
requests.packages.urllib3.disable_warnings()
def PrintException():
exc_type, exc_obj, tb = sys.exc_info()
f = tb.tb_frame
lineno = tb.tb_lineno
filename = f.f_code.co_filename
linecache.checkcache(filename)
line = linecache.getline(filename, lineno, f.f_globals)
print 'EXCEPTION IN ({}, LINE {} "{}"): {}'.format(filename, lineno, line.strip(), exc_obj)
def get_args():
parser = argparse.ArgumentParser(description='Arguments for talking to vCenter and modifying a PerfManager collection interval')
parser.add_argument('-s', '--host', required=True,action='store',help='vSpehre service to connect to')
parser.add_argument('-o', '--port', type=int, default=443, action='store', help='Port to connect on')
parser.add_argument('-u', '--user', required=True, action='store', help='User name to use')
parser.add_argument('-p', '--password', required=False, action='store', help='Password to use')
parser.add_argument('--interval-name', required=False, action='store', dest='intervalName', help='The name of the interval to modify')
parser.add_argument('--interval-key', required=False, action='store', dest='intervalKey', help='The key of the interval to modify')
parser.add_argument('--interval-level', type=int, required=True, default=4, action='store', dest='intervalLevel', help='The collection level wanted for the interval')
args = parser.parse_args()
if not args.password:
args.password = getpass.getpass(prompt='Enter password:\n')
if not args.intervalName and not args.intervalKey:
print "An interval name or key is needed"
exit(2)
return args
def change_level(host, user, pwd, port, level, key, name):
try:
print user
print pwd
print host
serviceInstance = SmartConnect(host=host,user=user,pwd=pwd,port=port)
atexit.register(Disconnect, serviceInstance)
content = serviceInstance.RetrieveContent()
pm = content.perfManager
for hi in pm.historicalInterval:
if (key and int(hi.key) == int(key)) or (name and str(hi.name) == str(name)):
print "Changing interval '" + str(hi.name) + "'"
newobj = hi
newobj.level = level
pm.UpdatePerfInterval(newobj)
print "Intervals are now configured as follows: "
print "Name | Level"
pm2 = content.perfManager
for hi2 in pm2.historicalInterval:
print hi2.name + " | " + str(hi2.level)
except Exception, e:
print "Error: %s " % (e)
PrintException()
exit(2)
if __name__ == "__main__":
args = get_args()
change_level(args.host, args.user, args.password, args.port, args.intervalLevel, args.intervalKey, args.intervalName)
================================================
FILE: tools/requirements.txt
================================================
pyVmomi
requests
argparse
================================================
FILE: vendor/github.com/davecgh/go-spew/.gitignore
================================================
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
================================================
FILE: vendor/github.com/davecgh/go-spew/.travis.yml
================================================
language: go
go:
- 1.5.4
- 1.6.3
- 1.7
install:
- go get -v golang.org/x/tools/cmd/cover
script:
- go test -v -tags=safe ./spew
- go test -v -tags=testcgo ./spew -covermode=count -coverprofile=profile.cov
after_success:
- go get -v github.com/mattn/goveralls
- export PATH=$PATH:$HOME/gopath/bin
- goveralls -coverprofile=profile.cov -service=travis-ci
================================================
FILE: vendor/github.com/davecgh/go-spew/LICENSE
================================================
ISC License
Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
================================================
FILE: vendor/github.com/davecgh/go-spew/README.md
================================================
go-spew
=======
[]
(https://travis-ci.org/davecgh/go-spew) [![ISC License]
(http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org) [![Coverage Status]
(https://img.shields.io/coveralls/davecgh/go-spew.svg)]
(https://coveralls.io/r/davecgh/go-spew?branch=master)
Go-spew implements a deep pretty printer for Go data structures to aid in
debugging. A comprehensive suite of tests with 100% test coverage is provided
to ensure proper functionality. See `test_coverage.txt` for the gocov coverage
report. Go-spew is licensed under the liberal ISC license, so it may be used in
open source or commercial projects.
If you're interested in reading about how this package came to life and some
of the challenges involved in providing a deep pretty printer, there is a blog
post about it
[here](https://web.archive.org/web/20160304013555/https://blog.cyphertite.com/go-spew-a-journey-into-dumping-go-data-structures/).
## Documentation
[]
(http://godoc.org/github.com/davecgh/go-spew/spew)
Full `go doc` style documentation for the project can be viewed online without
installing this package by using the excellent GoDoc site here:
http://godoc.org/github.com/davecgh/go-spew/spew
You can also view the documentation locally once the package is installed with
the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to
http://localhost:6060/pkg/github.com/davecgh/go-spew/spew
## Installation
```bash
$ go get -u github.com/davecgh/go-spew/spew
```
## Quick Start
Add this import line to the file you're working in:
```Go
import "github.com/davecgh/go-spew/spew"
```
To dump a variable with full newlines, indentation, type, and pointer
information use Dump, Fdump, or Sdump:
```Go
spew.Dump(myVar1, myVar2, ...)
spew.Fdump(someWriter, myVar1, myVar2, ...)
str := spew.Sdump(myVar1, myVar2, ...)
```
Alternatively, if you would prefer to use format strings with a compacted inline
printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most
compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types
and pointer addresses):
```Go
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
```
## Debugging a Web Application Example
Here is an example of how you can use `spew.Sdump()` to help debug a web application. Please be sure to wrap your output using the `html.EscapeString()` function for safety reasons. You should also only use this debugging technique in a development environment, never in production.
```Go
package main
import (
"fmt"
"html"
"net/http"
"github.com/davecgh/go-spew/spew"
)
func handler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])
fmt.Fprintf(w, "<!--\n" + html.EscapeString(spew.Sdump(w)) + "\n-->")
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
```
## Sample Dump Output
```
(main.Foo) {
unexportedField: (*main.Bar)(0xf84002e210)({
flag: (main.Flag) flagTwo,
data: (uintptr) <nil>
}),
ExportedField: (map[interface {}]interface {}) {
(string) "one": (bool) true
}
}
([]uint8) {
00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
00000020 31 32 |12|
}
```
## Sample Formatter Output
Double pointer to a uint8:
```
%v: <**>5
%+v: <**>(0xf8400420d0->0xf8400420c8)5
%#v: (**uint8)5
%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
```
Pointer to circular struct with a uint8 field and a pointer to itself:
```
%v: <*>{1 <*><shown>}
%+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
%#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
```
## Configuration Options
Configuration of spew is handled by fields in the ConfigState type. For
convenience, all of the top-level functions use a global state available via the
spew.Config global.
It is also possible to create a ConfigState instance that provides methods
equivalent to the top-level functions. This allows concurrent configuration
options. See the ConfigState documentation for more details.
```
* Indent
String to use for each indentation level for Dump functions.
It is a single space by default. A popular alternative is "\t".
* MaxDepth
Maximum number of levels to descend into nested data structures.
There is no limit by default.
* DisableMethods
Disables invocation of error and Stringer interface methods.
Method invocation is enabled by default.
* DisablePointerMethods
Disables invocation of error and Stringer interface methods on types
which only accept pointer receivers from non-pointer variables. This option
relies on access to the unsafe package, so it will not have any effect when
running in environments without access to the unsafe package such as Google
App Engine or with the "safe" build tag specified.
Pointer method invocation is enabled by default.
* DisablePointerAddresses
DisablePointerAddresses specifies whether to disable the printing of
pointer addresses. This is useful when diffing data structures in tests.
* DisableCapacities
DisableCapacities specifies whether to disable the printing of capacities
for arrays, slices, maps and channels. This is useful when diffing data
structures in tests.
* ContinueOnMethod
Enables recursion into types after invoking error and Stringer interface
methods. Recursion after method invocation is disabled by default.
* SortKeys
Specifies map keys should be sorted before being printed. Use
this to have a more deterministic, diffable output. Note that
only native types (bool, int, uint, floats, uintptr and string)
and types which implement error or Stringer interfaces are supported,
with other types sorted according to the reflect.Value.String() output
which guarantees display stability. Natural map order is used by
default.
* SpewKeys
SpewKeys specifies that, as a last resort attempt, map keys should be
spewed to strings and sorted by those strings. This is only considered
if SortKeys is true.
```
## Unsafe Package Dependency
This package relies on the unsafe package to perform some of the more advanced
features, however it also supports a "limited" mode which allows it to work in
environments where the unsafe package is not available. By default, it will
operate in this mode on Google App Engine and when compiled with GopherJS. The
"safe" build tag may also be specified to force the package to build without
using the unsafe package.
## License
Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.
================================================
FILE: vendor/github.com/davecgh/go-spew/cov_report.sh
================================================
#!/bin/sh
# This script uses gocov to generate a test coverage report.
# The gocov tool my be obtained with the following command:
# go get github.com/axw/gocov/gocov
#
# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
# Check for gocov.
if ! type gocov >/dev/null 2>&1; then
echo >&2 "This script requires the gocov tool."
echo >&2 "You may obtain it with the following command:"
echo >&2 "go get github.com/axw/gocov/gocov"
exit 1
fi
# Only run the cgo tests if gcc is installed.
if type gcc >/dev/null 2>&1; then
(cd spew && gocov test -tags testcgo | gocov report)
else
(cd spew && gocov test | gocov report)
fi
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/bypass.go
================================================
// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
// NOTE: Due to the following build constraints, this file will only be compiled
// when the code is not running on Google App Engine, compiled by GopherJS, and
// "-tags safe" is not added to the go build command line. The "disableunsafe"
// tag is deprecated and thus should not be used.
// +build !js,!appengine,!safe,!disableunsafe
package spew
import (
"reflect"
"unsafe"
)
const (
// UnsafeDisabled is a build-time constant which specifies whether or
// not access to the unsafe package is available.
UnsafeDisabled = false
// ptrSize is the size of a pointer on the current arch.
ptrSize = unsafe.Sizeof((*byte)(nil))
)
var (
// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
// internal reflect.Value fields. These values are valid before golang
// commit ecccf07e7f9d which changed the format. The are also valid
// after commit 82f48826c6c7 which changed the format again to mirror
// the original format. Code in the init function updates these offsets
// as necessary.
offsetPtr = uintptr(ptrSize)
offsetScalar = uintptr(0)
offsetFlag = uintptr(ptrSize * 2)
// flagKindWidth and flagKindShift indicate various bits that the
// reflect package uses internally to track kind information.
//
// flagRO indicates whether or not the value field of a reflect.Value is
// read-only.
//
// flagIndir indicates whether the value field of a reflect.Value is
// the actual data or a pointer to the data.
//
// These values are valid before golang commit 90a7c3c86944 which
// changed their positions. Code in the init function updates these
// flags as necessary.
flagKindWidth = uintptr(5)
flagKindShift = uintptr(flagKindWidth - 1)
flagRO = uintptr(1 << 0)
flagIndir = uintptr(1 << 1)
)
func init() {
// Older versions of reflect.Value stored small integers directly in the
// ptr field (which is named val in the older versions). Versions
// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
// scalar for this purpose which unfortunately came before the flag
// field, so the offset of the flag field is different for those
// versions.
//
// This code constructs a new reflect.Value from a known small integer
// and checks if the size of the reflect.Value struct indicates it has
// the scalar field. When it does, the offsets are updated accordingly.
vv := reflect.ValueOf(0xf00)
if unsafe.Sizeof(vv) == (ptrSize * 4) {
offsetScalar = ptrSize * 2
offsetFlag = ptrSize * 3
}
// Commit 90a7c3c86944 changed the flag positions such that the low
// order bits are the kind. This code extracts the kind from the flags
// field and ensures it's the correct type. When it's not, the flag
// order has been changed to the newer format, so the flags are updated
// accordingly.
upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
upfv := *(*uintptr)(upf)
flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
flagKindShift = 0
flagRO = 1 << 5
flagIndir = 1 << 6
// Commit adf9b30e5594 modified the flags to separate the
// flagRO flag into two bits which specifies whether or not the
// field is embedded. This causes flagIndir to move over a bit
// and means that flagRO is the combination of either of the
// original flagRO bit and the new bit.
//
// This code detects the change by extracting what used to be
// the indirect bit to ensure it's set. When it's not, the flag
// order has been changed to the newer format, so the flags are
// updated accordingly.
if upfv&flagIndir == 0 {
flagRO = 3 << 5
flagIndir = 1 << 7
}
}
}
// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
// the typical safety restrictions preventing access to unaddressable and
// unexported data. It works by digging the raw pointer to the underlying
// value out of the protected value and generating a new unprotected (unsafe)
// reflect.Value to it.
//
// This allows us to check for implementations of the Stringer and error
// interfaces to be used for pretty printing ordinarily unaddressable and
// inaccessible values such as unexported struct fields.
func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
indirects := 1
vt := v.Type()
upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
if rvf&flagIndir != 0 {
vt = reflect.PtrTo(v.Type())
indirects++
} else if offsetScalar != 0 {
// The value is in the scalar field when it's not one of the
// reference types.
switch vt.Kind() {
case reflect.Uintptr:
case reflect.Chan:
case reflect.Func:
case reflect.Map:
case reflect.Ptr:
case reflect.UnsafePointer:
default:
upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
offsetScalar)
}
}
pv := reflect.NewAt(vt, upv)
rv = pv
for i := 0; i < indirects; i++ {
rv = rv.Elem()
}
return rv
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
================================================
// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
// NOTE: Due to the following build constraints, this file will only be compiled
// when the code is running on Google App Engine, compiled by GopherJS, or
// "-tags safe" is added to the go build command line. The "disableunsafe"
// tag is deprecated and thus should not be used.
// +build js appengine safe disableunsafe
package spew
import "reflect"
const (
// UnsafeDisabled is a build-time constant which specifies whether or
// not access to the unsafe package is available.
UnsafeDisabled = true
)
// unsafeReflectValue typically converts the passed reflect.Value into a one
// that bypasses the typical safety restrictions preventing access to
// unaddressable and unexported data. However, doing this relies on access to
// the unsafe package. This is a stub version which simply returns the passed
// reflect.Value when the unsafe package is not available.
func unsafeReflectValue(v reflect.Value) reflect.Value {
return v
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/common.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"fmt"
"io"
"reflect"
"sort"
"strconv"
)
// Some constants in the form of bytes to avoid string overhead. This mirrors
// the technique used in the fmt package.
var (
panicBytes = []byte("(PANIC=")
plusBytes = []byte("+")
iBytes = []byte("i")
trueBytes = []byte("true")
falseBytes = []byte("false")
interfaceBytes = []byte("(interface {})")
commaNewlineBytes = []byte(",\n")
newlineBytes = []byte("\n")
openBraceBytes = []byte("{")
openBraceNewlineBytes = []byte("{\n")
closeBraceBytes = []byte("}")
asteriskBytes = []byte("*")
colonBytes = []byte(":")
colonSpaceBytes = []byte(": ")
openParenBytes = []byte("(")
closeParenBytes = []byte(")")
spaceBytes = []byte(" ")
pointerChainBytes = []byte("->")
nilAngleBytes = []byte("<nil>")
maxNewlineBytes = []byte("<max depth reached>\n")
maxShortBytes = []byte("<max>")
circularBytes = []byte("<already shown>")
circularShortBytes = []byte("<shown>")
invalidAngleBytes = []byte("<invalid>")
openBracketBytes = []byte("[")
closeBracketBytes = []byte("]")
percentBytes = []byte("%")
precisionBytes = []byte(".")
openAngleBytes = []byte("<")
closeAngleBytes = []byte(">")
openMapBytes = []byte("map[")
closeMapBytes = []byte("]")
lenEqualsBytes = []byte("len=")
capEqualsBytes = []byte("cap=")
)
// hexDigits is used to map a decimal value to a hex digit.
var hexDigits = "0123456789abcdef"
// catchPanic handles any panics that might occur during the handleMethods
// calls.
func catchPanic(w io.Writer, v reflect.Value) {
if err := recover(); err != nil {
w.Write(panicBytes)
fmt.Fprintf(w, "%v", err)
w.Write(closeParenBytes)
}
}
// handleMethods attempts to call the Error and String methods on the underlying
// type the passed reflect.Value represents and outputes the result to Writer w.
//
// It handles panics in any called methods by catching and displaying the error
// as the formatted value.
func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
// We need an interface to check if the type implements the error or
// Stringer interface. However, the reflect package won't give us an
// interface on certain things like unexported struct fields in order
// to enforce visibility rules. We use unsafe, when it's available,
// to bypass these restrictions since this package does not mutate the
// values.
if !v.CanInterface() {
if UnsafeDisabled {
return false
}
v = unsafeReflectValue(v)
}
// Choose whether or not to do error and Stringer interface lookups against
// the base type or a pointer to the base type depending on settings.
// Technically calling one of these methods with a pointer receiver can
// mutate the value, however, types which choose to satisify an error or
// Stringer interface with a pointer receiver should not be mutating their
// state inside these interface methods.
if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
v = unsafeReflectValue(v)
}
if v.CanAddr() {
v = v.Addr()
}
// Is it an error or Stringer?
switch iface := v.Interface().(type) {
case error:
defer catchPanic(w, v)
if cs.ContinueOnMethod {
w.Write(openParenBytes)
w.Write([]byte(iface.Error()))
w.Write(closeParenBytes)
w.Write(spaceBytes)
return false
}
w.Write([]byte(iface.Error()))
return true
case fmt.Stringer:
defer catchPanic(w, v)
if cs.ContinueOnMethod {
w.Write(openParenBytes)
w.Write([]byte(iface.String()))
w.Write(closeParenBytes)
w.Write(spaceBytes)
return false
}
w.Write([]byte(iface.String()))
return true
}
return false
}
// printBool outputs a boolean value as true or false to Writer w.
func printBool(w io.Writer, val bool) {
if val {
w.Write(trueBytes)
} else {
w.Write(falseBytes)
}
}
// printInt outputs a signed integer value to Writer w.
func printInt(w io.Writer, val int64, base int) {
w.Write([]byte(strconv.FormatInt(val, base)))
}
// printUint outputs an unsigned integer value to Writer w.
func printUint(w io.Writer, val uint64, base int) {
w.Write([]byte(strconv.FormatUint(val, base)))
}
// printFloat outputs a floating point value using the specified precision,
// which is expected to be 32 or 64bit, to Writer w.
func printFloat(w io.Writer, val float64, precision int) {
w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
}
// printComplex outputs a complex value using the specified float precision
// for the real and imaginary parts to Writer w.
func printComplex(w io.Writer, c complex128, floatPrecision int) {
r := real(c)
w.Write(openParenBytes)
w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
i := imag(c)
if i >= 0 {
w.Write(plusBytes)
}
w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
w.Write(iBytes)
w.Write(closeParenBytes)
}
// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
// prefix to Writer w.
func printHexPtr(w io.Writer, p uintptr) {
// Null pointer.
num := uint64(p)
if num == 0 {
w.Write(nilAngleBytes)
return
}
// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
buf := make([]byte, 18)
// It's simpler to construct the hex string right to left.
base := uint64(16)
i := len(buf) - 1
for num >= base {
buf[i] = hexDigits[num%base]
num /= base
i--
}
buf[i] = hexDigits[num]
// Add '0x' prefix.
i--
buf[i] = 'x'
i--
buf[i] = '0'
// Strip unused leading bytes.
buf = buf[i:]
w.Write(buf)
}
// valuesSorter implements sort.Interface to allow a slice of reflect.Value
// elements to be sorted.
type valuesSorter struct {
values []reflect.Value
strings []string // either nil or same len and values
cs *ConfigState
}
// newValuesSorter initializes a valuesSorter instance, which holds a set of
// surrogate keys on which the data should be sorted. It uses flags in
// ConfigState to decide if and how to populate those surrogate keys.
func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
vs := &valuesSorter{values: values, cs: cs}
if canSortSimply(vs.values[0].Kind()) {
return vs
}
if !cs.DisableMethods {
vs.strings = make([]string, len(values))
for i := range vs.values {
b := bytes.Buffer{}
if !handleMethods(cs, &b, vs.values[i]) {
vs.strings = nil
break
}
vs.strings[i] = b.String()
}
}
if vs.strings == nil && cs.SpewKeys {
vs.strings = make([]string, len(values))
for i := range vs.values {
vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
}
}
return vs
}
// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
// directly, or whether it should be considered for sorting by surrogate keys
// (if the ConfigState allows it).
func canSortSimply(kind reflect.Kind) bool {
// This switch parallels valueSortLess, except for the default case.
switch kind {
case reflect.Bool:
return true
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
return true
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
return true
case reflect.Float32, reflect.Float64:
return true
case reflect.String:
return true
case reflect.Uintptr:
return true
case reflect.Array:
return true
}
return false
}
// Len returns the number of values in the slice. It is part of the
// sort.Interface implementation.
func (s *valuesSorter) Len() int {
return len(s.values)
}
// Swap swaps the values at the passed indices. It is part of the
// sort.Interface implementation.
func (s *valuesSorter) Swap(i, j int) {
s.values[i], s.values[j] = s.values[j], s.values[i]
if s.strings != nil {
s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
}
}
// valueSortLess returns whether the first value should sort before the second
// value. It is used by valueSorter.Less as part of the sort.Interface
// implementation.
func valueSortLess(a, b reflect.Value) bool {
switch a.Kind() {
case reflect.Bool:
return !a.Bool() && b.Bool()
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
return a.Int() < b.Int()
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
return a.Uint() < b.Uint()
case reflect.Float32, reflect.Float64:
return a.Float() < b.Float()
case reflect.String:
return a.String() < b.String()
case reflect.Uintptr:
return a.Uint() < b.Uint()
case reflect.Array:
// Compare the contents of both arrays.
l := a.Len()
for i := 0; i < l; i++ {
av := a.Index(i)
bv := b.Index(i)
if av.Interface() == bv.Interface() {
continue
}
return valueSortLess(av, bv)
}
}
return a.String() < b.String()
}
// Less returns whether the value at index i should sort before the
// value at index j. It is part of the sort.Interface implementation.
func (s *valuesSorter) Less(i, j int) bool {
if s.strings == nil {
return valueSortLess(s.values[i], s.values[j])
}
return s.strings[i] < s.strings[j]
}
// sortValues is a sort function that handles both native types and any type that
// can be converted to error or Stringer. Other inputs are sorted according to
// their Value.String() value to ensure display stability.
func sortValues(values []reflect.Value, cs *ConfigState) {
if len(values) == 0 {
return
}
sort.Sort(newValuesSorter(values, cs))
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/common_test.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew_test
import (
"fmt"
"reflect"
"testing"
"github.com/davecgh/go-spew/spew"
)
// custom type to test Stinger interface on non-pointer receiver.
type stringer string
// String implements the Stringer interface for testing invocation of custom
// stringers on types with non-pointer receivers.
func (s stringer) String() string {
return "stringer " + string(s)
}
// custom type to test Stinger interface on pointer receiver.
type pstringer string
// String implements the Stringer interface for testing invocation of custom
// stringers on types with only pointer receivers.
func (s *pstringer) String() string {
return "stringer " + string(*s)
}
// xref1 and xref2 are cross referencing structs for testing circular reference
// detection.
type xref1 struct {
ps2 *xref2
}
type xref2 struct {
ps1 *xref1
}
// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular
// reference for testing detection.
type indirCir1 struct {
ps2 *indirCir2
}
type indirCir2 struct {
ps3 *indirCir3
}
type indirCir3 struct {
ps1 *indirCir1
}
// embed is used to test embedded structures.
type embed struct {
a string
}
// embedwrap is used to test embedded structures.
type embedwrap struct {
*embed
e *embed
}
// panicer is used to intentionally cause a panic for testing spew properly
// handles them
type panicer int
func (p panicer) String() string {
panic("test panic")
}
// customError is used to test custom error interface invocation.
type customError int
func (e customError) Error() string {
return fmt.Sprintf("error: %d", int(e))
}
// stringizeWants converts a slice of wanted test output into a format suitable
// for a test error message.
func stringizeWants(wants []string) string {
s := ""
for i, want := range wants {
if i > 0 {
s += fmt.Sprintf("want%d: %s", i+1, want)
} else {
s += "want: " + want
}
}
return s
}
// testFailed returns whether or not a test failed by checking if the result
// of the test is in the slice of wanted strings.
func testFailed(result string, wants []string) bool {
for _, want := range wants {
if result == want {
return false
}
}
return true
}
type sortableStruct struct {
x int
}
func (ss sortableStruct) String() string {
return fmt.Sprintf("ss.%d", ss.x)
}
type unsortableStruct struct {
x int
}
type sortTestCase struct {
input []reflect.Value
expected []reflect.Value
}
func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T) {
getInterfaces := func(values []reflect.Value) []interface{} {
interfaces := []interface{}{}
for _, v := range values {
interfaces = append(interfaces, v.Interface())
}
return interfaces
}
for _, test := range tests {
spew.SortValues(test.input, cs)
// reflect.DeepEqual cannot really make sense of reflect.Value,
// probably because of all the pointer tricks. For instance,
// v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}
// instead.
input := getInterfaces(test.input)
expected := getInterfaces(test.expected)
if !reflect.DeepEqual(input, expected) {
t.Errorf("Sort mismatch:\n %v != %v", input, expected)
}
}
}
// TestSortValues ensures the sort functionality for relect.Value based sorting
// works as intended.
func TestSortValues(t *testing.T) {
v := reflect.ValueOf
a := v("a")
b := v("b")
c := v("c")
embedA := v(embed{"a"})
embedB := v(embed{"b"})
embedC := v(embed{"c"})
tests := []sortTestCase{
// No values.
{
[]reflect.Value{},
[]reflect.Value{},
},
// Bools.
{
[]reflect.Value{v(false), v(true), v(false)},
[]reflect.Value{v(false), v(false), v(true)},
},
// Ints.
{
[]reflect.Value{v(2), v(1), v(3)},
[]reflect.Value{v(1), v(2), v(3)},
},
// Uints.
{
[]reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},
[]reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},
},
// Floats.
{
[]reflect.Value{v(2.0), v(1.0), v(3.0)},
[]reflect.Value{v(1.0), v(2.0), v(3.0)},
},
// Strings.
{
[]reflect.Value{b, a, c},
[]reflect.Value{a, b, c},
},
// Array
{
[]reflect.Value{v([3]int{3, 2, 1}), v([3]int{1, 3, 2}), v([3]int{1, 2, 3})},
[]reflect.Value{v([3]int{1, 2, 3}), v([3]int{1, 3, 2}), v([3]int{3, 2, 1})},
},
// Uintptrs.
{
[]reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},
[]reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},
},
// SortableStructs.
{
// Note: not sorted - DisableMethods is set.
[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
},
// UnsortableStructs.
{
// Note: not sorted - SpewKeys is false.
[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
},
// Invalid.
{
[]reflect.Value{embedB, embedA, embedC},
[]reflect.Value{embedB, embedA, embedC},
},
}
cs := spew.ConfigState{DisableMethods: true, SpewKeys: false}
helpTestSortValues(tests, &cs, t)
}
// TestSortValuesWithMethods ensures the sort functionality for relect.Value
// based sorting works as intended when using string methods.
func TestSortValuesWithMethods(t *testing.T) {
v := reflect.ValueOf
a := v("a")
b := v("b")
c := v("c")
tests := []sortTestCase{
// Ints.
{
[]reflect.Value{v(2), v(1), v(3)},
[]reflect.Value{v(1), v(2), v(3)},
},
// Strings.
{
[]reflect.Value{b, a, c},
[]reflect.Value{a, b, c},
},
// SortableStructs.
{
[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
},
// UnsortableStructs.
{
// Note: not sorted - SpewKeys is false.
[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
},
}
cs := spew.ConfigState{DisableMethods: false, SpewKeys: false}
helpTestSortValues(tests, &cs, t)
}
// TestSortValuesWithSpew ensures the sort functionality for relect.Value
// based sorting works as intended when using spew to stringify keys.
func TestSortValuesWithSpew(t *testing.T) {
v := reflect.ValueOf
a := v("a")
b := v("b")
c := v("c")
tests := []sortTestCase{
// Ints.
{
[]reflect.Value{v(2), v(1), v(3)},
[]reflect.Value{v(1), v(2), v(3)},
},
// Strings.
{
[]reflect.Value{b, a, c},
[]reflect.Value{a, b, c},
},
// SortableStructs.
{
[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
},
// UnsortableStructs.
{
[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
[]reflect.Value{v(unsortableStruct{1}), v(unsortableStruct{2}), v(unsortableStruct{3})},
},
}
cs := spew.ConfigState{DisableMethods: true, SpewKeys: true}
helpTestSortValues(tests, &cs, t)
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/config.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"fmt"
"io"
"os"
)
// ConfigState houses the configuration options used by spew to format and
// display values. There is a global instance, Config, that is used to control
// all top-level Formatter and Dump functionality. Each ConfigState instance
// provides methods equivalent to the top-level functions.
//
// The zero value for ConfigState provides no indentation. You would typically
// want to set it to a space or a tab.
//
// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
// with default settings. See the documentation of NewDefaultConfig for default
// values.
type ConfigState struct {
// Indent specifies the string to use for each indentation level. The
// global config instance that all top-level functions use set this to a
// single space by default. If you would like more indentation, you might
// set this to a tab with "\t" or perhaps two spaces with " ".
Indent string
// MaxDepth controls the maximum number of levels to descend into nested
// data structures. The default, 0, means there is no limit.
//
// NOTE: Circular data structures are properly detected, so it is not
// necessary to set this value unless you specifically want to limit deeply
// nested data structures.
MaxDepth int
// DisableMethods specifies whether or not error and Stringer interfaces are
// invoked for types that implement them.
DisableMethods bool
// DisablePointerMethods specifies whether or not to check for and invoke
// error and Stringer interfaces on types which only accept a pointer
// receiver when the current type is not a pointer.
//
// NOTE: This might be an unsafe action since calling one of these methods
// with a pointer receiver could technically mutate the value, however,
// in practice, types which choose to satisify an error or Stringer
// interface with a pointer receiver should not be mutating their state
// inside these interface methods. As a result, this option relies on
// access to the unsafe package, so it will not have any effect when
// running in environments without access to the unsafe package such as
// Google App Engine or with the "safe" build tag specified.
DisablePointerMethods bool
// DisablePointerAddresses specifies whether to disable the printing of
// pointer addresses. This is useful when diffing data structures in tests.
DisablePointerAddresses bool
// DisableCapacities specifies whether to disable the printing of capacities
// for arrays, slices, maps and channels. This is useful when diffing
// data structures in tests.
DisableCapacities bool
// ContinueOnMethod specifies whether or not recursion should continue once
// a custom error or Stringer interface is invoked. The default, false,
// means it will print the results of invoking the custom error or Stringer
// interface and return immediately instead of continuing to recurse into
// the internals of the data type.
//
// NOTE: This flag does not have any effect if method invocation is disabled
// via the DisableMethods or DisablePointerMethods options.
ContinueOnMethod bool
// SortKeys specifies map keys should be sorted before being printed. Use
// this to have a more deterministic, diffable output. Note that only
// native types (bool, int, uint, floats, uintptr and string) and types
// that support the error or Stringer interfaces (if methods are
// enabled) are supported, with other types sorted according to the
// reflect.Value.String() output which guarantees display stability.
SortKeys bool
// SpewKeys specifies that, as a last resort attempt, map keys should
// be spewed to strings and sorted by those strings. This is only
// considered if SortKeys is true.
SpewKeys bool
}
// Config is the active configuration of the top-level functions.
// The configuration can be changed by modifying the contents of spew.Config.
var Config = ConfigState{Indent: " "}
// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the formatted string as a value that satisfies error. See NewFormatter
// for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
return fmt.Errorf(format, c.convertArgs(a)...)
}
// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprint(w, c.convertArgs(a)...)
}
// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
return fmt.Fprintf(w, format, c.convertArgs(a)...)
}
// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
// passed with a Formatter interface returned by c.NewFormatter. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprintln(w, c.convertArgs(a)...)
}
// Print is a wrapper for fmt.Print that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
return fmt.Print(c.convertArgs(a)...)
}
// Printf is a wrapper for fmt.Printf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
return fmt.Printf(format, c.convertArgs(a)...)
}
// Println is a wrapper for fmt.Println that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
return fmt.Println(c.convertArgs(a)...)
}
// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Sprint(a ...interface{}) string {
return fmt.Sprint(c.convertArgs(a)...)
}
// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
return fmt.Sprintf(format, c.convertArgs(a)...)
}
// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
// were passed with a Formatter interface returned by c.NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Sprintln(a ...interface{}) string {
return fmt.Sprintln(c.convertArgs(a)...)
}
/*
NewFormatter returns a custom formatter that satisfies the fmt.Formatter
interface. As a result, it integrates cleanly with standard fmt package
printing functions. The formatter is useful for inline printing of smaller data
types similar to the standard %v format specifier.
The custom formatter only responds to the %v (most compact), %+v (adds pointer
addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
combinations. Any other verbs such as %x and %q will be sent to the the
standard fmt package for formatting. In addition, the custom formatter ignores
the width and precision arguments (however they will still work on the format
specifiers not handled by the custom formatter).
Typically this function shouldn't be called directly. It is much easier to make
use of the custom formatter by calling one of the convenience functions such as
c.Printf, c.Println, or c.Printf.
*/
func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
return newFormatter(c, v)
}
// Fdump formats and displays the passed arguments to io.Writer w. It formats
// exactly the same as Dump.
func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
fdump(c, w, a...)
}
/*
Dump displays the passed parameters to standard out with newlines, customizable
indentation, and additional debug information such as complete types and all
pointer addresses used to indirect to the final value. It provides the
following features over the built-in printing facilities provided by the fmt
package:
* Pointers are dereferenced and followed
* Circular data structures are detected and handled properly
* Custom Stringer/error interfaces are optionally invoked, including
on unexported types
* Custom types which only implement the Stringer/error interfaces via
a pointer receiver are optionally invoked when passing non-pointer
variables
* Byte arrays and slices are dumped like the hexdump -C command which
includes offsets, byte values in hex, and ASCII output
The configuration options are controlled by modifying the public members
of c. See ConfigState for options documentation.
See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
get the formatted result as a string.
*/
func (c *ConfigState) Dump(a ...interface{}) {
fdump(c, os.Stdout, a...)
}
// Sdump returns a string with the passed arguments formatted exactly the same
// as Dump.
func (c *ConfigState) Sdump(a ...interface{}) string {
var buf bytes.Buffer
fdump(c, &buf, a...)
return buf.String()
}
// convertArgs accepts a slice of arguments and returns a slice of the same
// length with each argument converted to a spew Formatter interface using
// the ConfigState associated with s.
func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
formatters = make([]interface{}, len(args))
for index, arg := range args {
formatters[index] = newFormatter(c, arg)
}
return formatters
}
// NewDefaultConfig returns a ConfigState with the following default settings.
//
// Indent: " "
// MaxDepth: 0
// DisableMethods: false
// DisablePointerMethods: false
// ContinueOnMethod: false
// SortKeys: false
func NewDefaultConfig() *ConfigState {
return &ConfigState{Indent: " "}
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/doc.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
Package spew implements a deep pretty printer for Go data structures to aid in
debugging.
A quick overview of the additional features spew provides over the built-in
printing facilities for Go data types are as follows:
* Pointers are dereferenced and followed
* Circular data structures are detected and handled properly
* Custom Stringer/error interfaces are optionally invoked, including
on unexported types
* Custom types which only implement the Stringer/error interfaces via
a pointer receiver are optionally invoked when passing non-pointer
variables
* Byte arrays and slices are dumped like the hexdump -C command which
includes offsets, byte values in hex, and ASCII output (only when using
Dump style)
There are two different approaches spew allows for dumping Go data structures:
* Dump style which prints with newlines, customizable indentation,
and additional debug information such as types and all pointer addresses
used to indirect to the final value
* A custom Formatter interface that integrates cleanly with the standard fmt
package and replaces %v, %+v, %#v, and %#+v to provide inline printing
similar to the default %v while providing the additional functionality
outlined above and passing unsupported format verbs such as %x and %q
along to fmt
Quick Start
This section demonstrates how to quickly get started with spew. See the
sections below for further details on formatting and configuration options.
To dump a variable with full newlines, indentation, type, and pointer
information use Dump, Fdump, or Sdump:
spew.Dump(myVar1, myVar2, ...)
spew.Fdump(someWriter, myVar1, myVar2, ...)
str := spew.Sdump(myVar1, myVar2, ...)
Alternatively, if you would prefer to use format strings with a compacted inline
printing style, use the convenience wrappers Printf, Fprintf, etc with
%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
%#+v (adds types and pointer addresses):
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
Configuration Options
Configuration of spew is handled by fields in the ConfigState type. For
convenience, all of the top-level functions use a global state available
via the spew.Config global.
It is also possible to create a ConfigState instance that provides methods
equivalent to the top-level functions. This allows concurrent configuration
options. See the ConfigState documentation for more details.
The following configuration options are available:
* Indent
String to use for each indentation level for Dump functions.
It is a single space by default. A popular alternative is "\t".
* MaxDepth
Maximum number of levels to descend into nested data structures.
There is no limit by default.
* DisableMethods
Disables invocation of error and Stringer interface methods.
Method invocation is enabled by default.
* DisablePointerMethods
Disables invocation of error and Stringer interface methods on types
which only accept pointer receivers from non-pointer variables.
Pointer method invocation is enabled by default.
* DisablePointerAddresses
DisablePointerAddresses specifies whether to disable the printing of
pointer addresses. This is useful when diffing data structures in tests.
* DisableCapacities
DisableCapacities specifies whether to disable the printing of
capacities for arrays, slices, maps and channels. This is useful when
diffing data structures in tests.
* ContinueOnMethod
Enables recursion into types after invoking error and Stringer interface
methods. Recursion after method invocation is disabled by default.
* SortKeys
Specifies map keys should be sorted before being printed. Use
this to have a more deterministic, diffable output. Note that
only native types (bool, int, uint, floats, uintptr and string)
and types which implement error or Stringer interfaces are
supported with other types sorted according to the
reflect.Value.String() output which guarantees display
stability. Natural map order is used by default.
* SpewKeys
Specifies that, as a last resort attempt, map keys should be
spewed to strings and sorted by those strings. This is only
considered if SortKeys is true.
Dump Usage
Simply call spew.Dump with a list of variables you want to dump:
spew.Dump(myVar1, myVar2, ...)
You may also call spew.Fdump if you would prefer to output to an arbitrary
io.Writer. For example, to dump to standard error:
spew.Fdump(os.Stderr, myVar1, myVar2, ...)
A third option is to call spew.Sdump to get the formatted output as a string:
str := spew.Sdump(myVar1, myVar2, ...)
Sample Dump Output
See the Dump example for details on the setup of the types and variables being
shown here.
(main.Foo) {
unexportedField: (*main.Bar)(0xf84002e210)({
flag: (main.Flag) flagTwo,
data: (uintptr) <nil>
}),
ExportedField: (map[interface {}]interface {}) (len=1) {
(string) (len=3) "one": (bool) true
}
}
Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
command as shown.
([]uint8) (len=32 cap=32) {
00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
00000020 31 32 |12|
}
Custom Formatter
Spew provides a custom formatter that implements the fmt.Formatter interface
so that it integrates cleanly with standard fmt package printing functions. The
formatter is useful for inline printing of smaller data types similar to the
standard %v format specifier.
The custom formatter only responds to the %v (most compact), %+v (adds pointer
addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
combinations. Any other verbs such as %x and %q will be sent to the the
standard fmt package for formatting. In addition, the custom formatter ignores
the width and precision arguments (however they will still work on the format
specifiers not handled by the custom formatter).
Custom Formatter Usage
The simplest way to make use of the spew custom formatter is to call one of the
convenience functions such as spew.Printf, spew.Println, or spew.Printf. The
functions have syntax you are most likely already familiar with:
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Println(myVar, myVar2)
spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
See the Index for the full list convenience functions.
Sample Formatter Output
Double pointer to a uint8:
%v: <**>5
%+v: <**>(0xf8400420d0->0xf8400420c8)5
%#v: (**uint8)5
%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
Pointer to circular struct with a uint8 field and a pointer to itself:
%v: <*>{1 <*><shown>}
%+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
%#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
See the Printf example for details on the setup of variables being shown
here.
Errors
Since it is possible for custom Stringer/error interfaces to panic, spew
detects them and handles them internally by printing the panic information
inline with the output. Since spew is intended to provide deep pretty printing
capabilities on structures, it intentionally does not return any errors.
*/
package spew
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/dump.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"encoding/hex"
"fmt"
"io"
"os"
"reflect"
"regexp"
"strconv"
"strings"
)
var (
// uint8Type is a reflect.Type representing a uint8. It is used to
// convert cgo types to uint8 slices for hexdumping.
uint8Type = reflect.TypeOf(uint8(0))
// cCharRE is a regular expression that matches a cgo char.
// It is used to detect character arrays to hexdump them.
cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
// cUnsignedCharRE is a regular expression that matches a cgo unsigned
// char. It is used to detect unsigned character arrays to hexdump
// them.
cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
// It is used to detect uint8_t arrays to hexdump them.
cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
)
// dumpState contains information about the state of a dump operation.
type dumpState struct {
w io.Writer
depth int
pointers map[uintptr]int
ignoreNextType bool
ignoreNextIndent bool
cs *ConfigState
}
// indent performs indentation according to the depth level and cs.Indent
// option.
func (d *dumpState) indent() {
if d.ignoreNextIndent {
d.ignoreNextIndent = false
return
}
d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
}
// unpackValue returns values inside of non-nil interfaces when possible.
// This is useful for data types like structs, arrays, slices, and maps which
// can contain varying types packed inside an interface.
func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Interface && !v.IsNil() {
v = v.Elem()
}
return v
}
// dumpPtr handles formatting of pointers by indirecting them as necessary.
func (d *dumpState) dumpPtr(v reflect.Value) {
// Remove pointers at or below the current depth from map used to detect
// circular refs.
for k, depth := range d.pointers {
if depth >= d.depth {
delete(d.pointers, k)
}
}
// Keep list of all dereferenced pointers to show later.
pointerChain := make([]uintptr, 0)
// Figure out how many levels of indirection there are by dereferencing
// pointers and unpacking interfaces down the chain while detecting circular
// references.
nilFound := false
cycleFound := false
indirects := 0
ve := v
for ve.Kind() == reflect.Ptr {
if ve.IsNil() {
nilFound = true
break
}
indirects++
addr := ve.Pointer()
pointerChain = append(pointerChain, addr)
if pd, ok := d.pointers[addr]; ok && pd < d.depth {
cycleFound = true
indirects--
break
}
d.pointers[addr] = d.depth
ve = ve.Elem()
if ve.Kind() == reflect.Interface {
if ve.IsNil() {
nilFound = true
break
}
ve = ve.Elem()
}
}
// Display type information.
d.w.Write(openParenBytes)
d.w.Write(bytes.Repeat(asteriskBytes, indirects))
d.w.Write([]byte(ve.Type().String()))
d.w.Write(closeParenBytes)
// Display pointer information.
if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
d.w.Write(openParenBytes)
for i, addr := range pointerChain {
if i > 0 {
d.w.Write(pointerChainBytes)
}
printHexPtr(d.w, addr)
}
d.w.Write(closeParenBytes)
}
// Display dereferenced value.
d.w.Write(openParenBytes)
switch {
case nilFound == true:
d.w.Write(nilAngleBytes)
case cycleFound == true:
d.w.Write(circularBytes)
default:
d.ignoreNextType = true
d.dump(ve)
}
d.w.Write(closeParenBytes)
}
// dumpSlice handles formatting of arrays and slices. Byte (uint8 under
// reflection) arrays and slices are dumped in hexdump -C fashion.
func (d *dumpState) dumpSlice(v reflect.Value) {
// Determine whether this type should be hex dumped or not. Also,
// for types which should be hexdumped, try to use the underlying data
// first, then fall back to trying to convert them to a uint8 slice.
var buf []uint8
doConvert := false
doHexDump := false
numEntries := v.Len()
if numEntries > 0 {
vt := v.Index(0).Type()
vts := vt.String()
switch {
// C types that need to be converted.
case cCharRE.MatchString(vts):
fallthrough
case cUnsignedCharRE.MatchString(vts):
fallthrough
case cUint8tCharRE.MatchString(vts):
doConvert = true
// Try to use existing uint8 slices and fall back to converting
// and copying if that fails.
case vt.Kind() == reflect.Uint8:
// We need an addressable interface to convert the type
// to a byte slice. However, the reflect package won't
// give us an interface on certain things like
// unexported struct fields in order to enforce
// visibility rules. We use unsafe, when available, to
// bypass these restrictions since this package does not
// mutate the values.
vs := v
if !vs.CanInterface() || !vs.CanAddr() {
vs = unsafeReflectValue(vs)
}
if !UnsafeDisabled {
vs = vs.Slice(0, numEntries)
// Use the existing uint8 slice if it can be
// type asserted.
iface := vs.Interface()
if slice, ok := iface.([]uint8); ok {
buf = slice
doHexDump = true
break
}
}
// The underlying data needs to be converted if it can't
// be type asserted to a uint8 slice.
doConvert = true
}
// Copy and convert the underlying type if needed.
if doConvert && vt.ConvertibleTo(uint8Type) {
// Convert and copy each element into a uint8 byte
// slice.
buf = make([]uint8, numEntries)
for i := 0; i < numEntries; i++ {
vv := v.Index(i)
buf[i] = uint8(vv.Convert(uint8Type).Uint())
}
doHexDump = true
}
}
// Hexdump the entire slice as needed.
if doHexDump {
indent := strings.Repeat(d.cs.Indent, d.depth)
str := indent + hex.Dump(buf)
str = strings.Replace(str, "\n", "\n"+indent, -1)
str = strings.TrimRight(str, d.cs.Indent)
d.w.Write([]byte(str))
return
}
// Recursively call dump for each item.
for i := 0; i < numEntries; i++ {
d.dump(d.unpackValue(v.Index(i)))
if i < (numEntries - 1) {
d.w.Write(commaNewlineBytes)
} else {
d.w.Write(newlineBytes)
}
}
}
// dump is the main workhorse for dumping a value. It uses the passed reflect
// value to figure out what kind of object we are dealing with and formats it
// appropriately. It is a recursive function, however circular data structures
// are detected and handled properly.
func (d *dumpState) dump(v reflect.Value) {
// Handle invalid reflect values immediately.
kind := v.Kind()
if kind == reflect.Invalid {
d.w.Write(invalidAngleBytes)
return
}
// Handle pointers specially.
if kind == reflect.Ptr {
d.indent()
d.dumpPtr(v)
return
}
// Print type information unless already handled elsewhere.
if !d.ignoreNextType {
d.indent()
d.w.Write(openParenBytes)
d.w.Write([]byte(v.Type().String()))
d.w.Write(closeParenBytes)
d.w.Write(spaceBytes)
}
d.ignoreNextType = false
// Display length and capacity if the built-in len and cap functions
// work with the value's kind and the len/cap itself is non-zero.
valueLen, valueCap := 0, 0
switch v.Kind() {
case reflect.Array, reflect.Slice, reflect.Chan:
valueLen, valueCap = v.Len(), v.Cap()
case reflect.Map, reflect.String:
valueLen = v.Len()
}
if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
d.w.Write(openParenBytes)
if valueLen != 0 {
d.w.Write(lenEqualsBytes)
printInt(d.w, int64(valueLen), 10)
}
if !d.cs.DisableCapacities && valueCap != 0 {
if valueLen != 0 {
d.w.Write(spaceBytes)
}
d.w.Write(capEqualsBytes)
printInt(d.w, int64(valueCap), 10)
}
d.w.Write(closeParenBytes)
d.w.Write(spaceBytes)
}
// Call Stringer/error interfaces if they exist and the handle methods flag
// is enabled
if !d.cs.DisableMethods {
if (kind != reflect.Invalid) && (kind != reflect.Interface) {
if handled := handleMethods(d.cs, d.w, v); handled {
return
}
}
}
switch kind {
case reflect.Invalid:
// Do nothing. We should never get here since invalid has already
// been handled above.
case reflect.Bool:
printBool(d.w, v.Bool())
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
printInt(d.w, v.Int(), 10)
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
printUint(d.w, v.Uint(), 10)
case reflect.Float32:
printFloat(d.w, v.Float(), 32)
case reflect.Float64:
printFloat(d.w, v.Float(), 64)
case reflect.Complex64:
printComplex(d.w, v.Complex(), 32)
case reflect.Complex128:
printComplex(d.w, v.Complex(), 64)
case reflect.Slice:
if v.IsNil() {
d.w.Write(nilAngleBytes)
break
}
fallthrough
case reflect.Array:
d.w.Write(openBraceNewlineBytes)
d.depth++
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
d.indent()
d.w.Write(maxNewlineBytes)
} else {
d.dumpSlice(v)
}
d.depth--
d.indent()
d.w.Write(closeBraceBytes)
case reflect.String:
d.w.Write([]byte(strconv.Quote(v.String())))
case reflect.Interface:
// The only time we should get here is for nil interfaces due to
// unpackValue calls.
if v.IsNil() {
d.w.Write(nilAngleBytes)
}
case reflect.Ptr:
// Do nothing. We should never get here since pointers have already
// been handled above.
case reflect.Map:
// nil maps should be indicated as different than empty maps
if v.IsNil() {
d.w.Write(nilAngleBytes)
break
}
d.w.Write(openBraceNewlineBytes)
d.depth++
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
d.indent()
d.w.Write(maxNewlineBytes)
} else {
numEntries := v.Len()
keys := v.MapKeys()
if d.cs.SortKeys {
sortValues(keys, d.cs)
}
for i, key := range keys {
d.dump(d.unpackValue(key))
d.w.Write(colonSpaceBytes)
d.ignoreNextIndent = true
d.dump(d.unpackValue(v.MapIndex(key)))
if i < (numEntries - 1) {
d.w.Write(commaNewlineBytes)
} else {
d.w.Write(newlineBytes)
}
}
}
d.depth--
d.indent()
d.w.Write(closeBraceBytes)
case reflect.Struct:
d.w.Write(openBraceNewlineBytes)
d.depth++
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
d.indent()
d.w.Write(maxNewlineBytes)
} else {
vt := v.Type()
numFields := v.NumField()
for i := 0; i < numFields; i++ {
d.indent()
vtf := vt.Field(i)
d.w.Write([]byte(vtf.Name))
d.w.Write(colonSpaceBytes)
d.ignoreNextIndent = true
d.dump(d.unpackValue(v.Field(i)))
if i < (numFields - 1) {
d.w.Write(commaNewlineBytes)
} else {
d.w.Write(newlineBytes)
}
}
}
d.depth--
d.indent()
d.w.Write(closeBraceBytes)
case reflect.Uintptr:
printHexPtr(d.w, uintptr(v.Uint()))
case reflect.UnsafePointer, reflect.Chan, reflect.Func:
printHexPtr(d.w, v.Pointer())
// There were not any other types at the time this code was written, but
// fall back to letting the default fmt package handle it in case any new
// types are added.
default:
if v.CanInterface() {
fmt.Fprintf(d.w, "%v", v.Interface())
} else {
fmt.Fprintf(d.w, "%v", v.String())
}
}
}
// fdump is a helper function to consolidate the logic from the various public
// methods which take varying writers and config states.
func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
for _, arg := range a {
if arg == nil {
w.Write(interfaceBytes)
w.Write(spaceBytes)
w.Write(nilAngleBytes)
w.Write(newlineBytes)
continue
}
d := dumpState{w: w, cs: cs}
d.pointers = make(map[uintptr]int)
d.dump(reflect.ValueOf(arg))
d.w.Write(newlineBytes)
}
}
// Fdump formats and displays the passed arguments to io.Writer w. It formats
// exactly the same as Dump.
func Fdump(w io.Writer, a ...interface{}) {
fdump(&Config, w, a...)
}
// Sdump returns a string with the passed arguments formatted exactly the same
// as Dump.
func Sdump(a ...interface{}) string {
var buf bytes.Buffer
fdump(&Config, &buf, a...)
return buf.String()
}
/*
Dump displays the passed parameters to standard out with newlines, customizable
indentation, and additional debug information such as complete types and all
pointer addresses used to indirect to the final value. It provides the
following features over the built-in printing facilities provided by the fmt
package:
* Pointers are dereferenced and followed
* Circular data structures are detected and handled properly
* Custom Stringer/error interfaces are optionally invoked, including
on unexported types
* Custom types which only implement the Stringer/error interfaces via
a pointer receiver are optionally invoked when passing non-pointer
variables
* Byte arrays and slices are dumped like the hexdump -C command which
includes offsets, byte values in hex, and ASCII output
The configuration options are controlled by an exported package global,
spew.Config. See ConfigState for options documentation.
See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
get the formatted result as a string.
*/
func Dump(a ...interface{}) {
fdump(&Config, os.Stdout, a...)
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/dump_test.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
Test Summary:
NOTE: For each test, a nil pointer, a single pointer and double pointer to the
base test element are also tested to ensure proper indirection across all types.
- Max int8, int16, int32, int64, int
- Max uint8, uint16, uint32, uint64, uint
- Boolean true and false
- Standard complex64 and complex128
- Array containing standard ints
- Array containing type with custom formatter on pointer receiver only
- Array containing interfaces
- Array containing bytes
- Slice containing standard float32 values
- Slice containing type with custom formatter on pointer receiver only
- Slice containing interfaces
- Slice containing bytes
- Nil slice
- Standard string
- Nil interface
- Sub-interface
- Map with string keys and int vals
- Map with custom formatter type on pointer receiver only keys and vals
- Map with interface keys and values
- Map with nil interface value
- Struct with primitives
- Struct that contains another struct
- Struct that contains custom type with Stringer pointer interface via both
exported and unexported fields
- Struct that contains embedded struct and field to same struct
- Uintptr to 0 (null pointer)
- Uintptr address of real variable
- Unsafe.Pointer to 0 (null pointer)
- Unsafe.Pointer to address of real variable
- Nil channel
- Standard int channel
- Function with no params and no returns
- Function with param and no returns
- Function with multiple params and multiple returns
- Struct that is circular through self referencing
- Structs that are circular through cross referencing
- Structs that are indirectly circular
- Type that panics in its Stringer interface
*/
package spew_test
import (
"bytes"
"fmt"
"testing"
"unsafe"
"github.com/davecgh/go-spew/spew"
)
// dumpTest is used to describe a test to be performed against the Dump method.
type dumpTest struct {
in interface{}
wants []string
}
// dumpTests houses all of the tests to be performed against the Dump method.
var dumpTests = make([]dumpTest, 0)
// addDumpTest is a helper method to append the passed input and desired result
// to dumpTests
func addDumpTest(in interface{}, wants ...string) {
test := dumpTest{in, wants}
dumpTests = append(dumpTests, test)
}
func addIntDumpTests() {
// Max int8.
v := int8(127)
nv := (*int8)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "int8"
vs := "127"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Max int16.
v2 := int16(32767)
nv2 := (*int16)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "int16"
v2s := "32767"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
// Max int32.
v3 := int32(2147483647)
nv3 := (*int32)(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "int32"
v3s := "2147483647"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
// Max int64.
v4 := int64(9223372036854775807)
nv4 := (*int64)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "int64"
v4s := "9223372036854775807"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
// Max int.
v5 := int(2147483647)
nv5 := (*int)(nil)
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "int"
v5s := "2147483647"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
}
func addUintDumpTests() {
// Max uint8.
v := uint8(255)
nv := (*uint8)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "uint8"
vs := "255"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Max uint16.
v2 := uint16(65535)
nv2 := (*uint16)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uint16"
v2s := "65535"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
// Max uint32.
v3 := uint32(4294967295)
nv3 := (*uint32)(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "uint32"
v3s := "4294967295"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
// Max uint64.
v4 := uint64(18446744073709551615)
nv4 := (*uint64)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "uint64"
v4s := "18446744073709551615"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
// Max uint.
v5 := uint(4294967295)
nv5 := (*uint)(nil)
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "uint"
v5s := "4294967295"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
}
func addBoolDumpTests() {
// Boolean true.
v := bool(true)
nv := (*bool)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "bool"
vs := "true"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Boolean false.
v2 := bool(false)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "bool"
v2s := "false"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
}
func addFloatDumpTests() {
// Standard float32.
v := float32(3.1415)
nv := (*float32)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "float32"
vs := "3.1415"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Standard float64.
v2 := float64(3.1415926)
nv2 := (*float64)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "float64"
v2s := "3.1415926"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
}
func addComplexDumpTests() {
// Standard complex64.
v := complex(float32(6), -2)
nv := (*complex64)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "complex64"
vs := "(6-2i)"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Standard complex128.
v2 := complex(float64(-6), 2)
nv2 := (*complex128)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "complex128"
v2s := "(-6+2i)"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
}
func addArrayDumpTests() {
// Array containing standard ints.
v := [3]int{1, 2, 3}
vLen := fmt.Sprintf("%d", len(v))
vCap := fmt.Sprintf("%d", cap(v))
nv := (*[3]int)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "int"
vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 1,\n (" +
vt + ") 2,\n (" + vt + ") 3\n}"
addDumpTest(v, "([3]"+vt+") "+vs+"\n")
addDumpTest(pv, "(*[3]"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**[3]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*[3]"+vt+")(<nil>)\n")
// Array containing type with custom formatter on pointer receiver only.
v2i0 := pstringer("1")
v2i1 := pstringer("2")
v2i2 := pstringer("3")
v2 := [3]pstringer{v2i0, v2i1, v2i2}
v2i0Len := fmt.Sprintf("%d", len(v2i0))
v2i1Len := fmt.Sprintf("%d", len(v2i1))
v2i2Len := fmt.Sprintf("%d", len(v2i2))
v2Len := fmt.Sprintf("%d", len(v2))
v2Cap := fmt.Sprintf("%d", cap(v2))
nv2 := (*[3]pstringer)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.pstringer"
v2sp := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
") (len=" + v2i0Len + ") stringer 1,\n (" + v2t +
") (len=" + v2i1Len + ") stringer 2,\n (" + v2t +
") (len=" + v2i2Len + ") " + "stringer 3\n}"
v2s := v2sp
if spew.UnsafeDisabled {
v2s = "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
") (len=" + v2i0Len + ") \"1\",\n (" + v2t + ") (len=" +
v2i1Len + ") \"2\",\n (" + v2t + ") (len=" + v2i2Len +
") " + "\"3\"\n}"
}
addDumpTest(v2, "([3]"+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*[3]"+v2t+")("+v2Addr+")("+v2sp+")\n")
addDumpTest(&pv2, "(**[3]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2sp+")\n")
addDumpTest(nv2, "(*[3]"+v2t+")(<nil>)\n")
// Array containing interfaces.
v3i0 := "one"
v3 := [3]interface{}{v3i0, int(2), uint(3)}
v3i0Len := fmt.Sprintf("%d", len(v3i0))
v3Len := fmt.Sprintf("%d", len(v3))
v3Cap := fmt.Sprintf("%d", cap(v3))
nv3 := (*[3]interface{})(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "[3]interface {}"
v3t2 := "string"
v3t3 := "int"
v3t4 := "uint"
v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
"(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
v3t4 + ") 3\n}"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
// Array containing bytes.
v4 := [34]byte{
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32,
}
v4Len := fmt.Sprintf("%d", len(v4))
v4Cap := fmt.Sprintf("%d", cap(v4))
nv4 := (*[34]byte)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "[34]uint8"
v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
"{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
" |............... |\n" +
" 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
" |!\"#$%&'()*+,-./0|\n" +
" 00000020 31 32 " +
" |12|\n}"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
}
func addSliceDumpTests() {
// Slice containing standard float32 values.
v := []float32{3.14, 6.28, 12.56}
vLen := fmt.Sprintf("%d", len(v))
vCap := fmt.Sprintf("%d", cap(v))
nv := (*[]float32)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "float32"
vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 3.14,\n (" +
vt + ") 6.28,\n (" + vt + ") 12.56\n}"
addDumpTest(v, "([]"+vt+") "+vs+"\n")
addDumpTest(pv, "(*[]"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**[]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*[]"+vt+")(<nil>)\n")
// Slice containing type with custom formatter on pointer receiver only.
v2i0 := pstringer("1")
v2i1 := pstringer("2")
v2i2 := pstringer("3")
v2 := []pstringer{v2i0, v2i1, v2i2}
v2i0Len := fmt.Sprintf("%d", len(v2i0))
v2i1Len := fmt.Sprintf("%d", len(v2i1))
v2i2Len := fmt.Sprintf("%d", len(v2i2))
v2Len := fmt.Sprintf("%d", len(v2))
v2Cap := fmt.Sprintf("%d", cap(v2))
nv2 := (*[]pstringer)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.pstringer"
v2s := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t + ") (len=" +
v2i0Len + ") stringer 1,\n (" + v2t + ") (len=" + v2i1Len +
") stringer 2,\n (" + v2t + ") (len=" + v2i2Len + ") " +
"stringer 3\n}"
addDumpTest(v2, "([]"+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*[]"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**[]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*[]"+v2t+")(<nil>)\n")
// Slice containing interfaces.
v3i0 := "one"
v3 := []interface{}{v3i0, int(2), uint(3), nil}
v3i0Len := fmt.Sprintf("%d", len(v3i0))
v3Len := fmt.Sprintf("%d", len(v3))
v3Cap := fmt.Sprintf("%d", cap(v3))
nv3 := (*[]interface{})(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "[]interface {}"
v3t2 := "string"
v3t3 := "int"
v3t4 := "uint"
v3t5 := "interface {}"
v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
"(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
v3t4 + ") 3,\n (" + v3t5 + ") <nil>\n}"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
// Slice containing bytes.
v4 := []byte{
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32,
}
v4Len := fmt.Sprintf("%d", len(v4))
v4Cap := fmt.Sprintf("%d", cap(v4))
nv4 := (*[]byte)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "[]uint8"
v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
"{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
" |............... |\n" +
" 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
" |!\"#$%&'()*+,-./0|\n" +
" 00000020 31 32 " +
" |12|\n}"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
// Nil slice.
v5 := []int(nil)
nv5 := (*[]int)(nil)
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "[]int"
v5s := "<nil>"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
}
func addStringDumpTests() {
// Standard string.
v := "test"
vLen := fmt.Sprintf("%d", len(v))
nv := (*string)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "string"
vs := "(len=" + vLen + ") \"test\""
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
}
func addInterfaceDumpTests() {
// Nil interface.
var v interface{}
nv := (*interface{})(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "interface {}"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Sub-interface.
v2 := interface{}(uint16(65535))
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uint16"
v2s := "65535"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
}
func addMapDumpTests() {
// Map with string keys and int vals.
k := "one"
kk := "two"
m := map[string]int{k: 1, kk: 2}
klen := fmt.Sprintf("%d", len(k)) // not kLen to shut golint up
kkLen := fmt.Sprintf("%d", len(kk))
mLen := fmt.Sprintf("%d", len(m))
nilMap := map[string]int(nil)
nm := (*map[string]int)(nil)
pm := &m
mAddr := fmt.Sprintf("%p", pm)
pmAddr := fmt.Sprintf("%p", &pm)
mt := "map[string]int"
mt1 := "string"
mt2 := "int"
ms := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + klen + ") " +
"\"one\": (" + mt2 + ") 1,\n (" + mt1 + ") (len=" + kkLen +
") \"two\": (" + mt2 + ") 2\n}"
ms2 := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + kkLen + ") " +
"\"two\": (" + mt2 + ") 2,\n (" + mt1 + ") (len=" + klen +
") \"one\": (" + mt2 + ") 1\n}"
addDumpTest(m, "("+mt+") "+ms+"\n", "("+mt+") "+ms2+"\n")
addDumpTest(pm, "(*"+mt+")("+mAddr+")("+ms+")\n",
"(*"+mt+")("+mAddr+")("+ms2+")\n")
addDumpTest(&pm, "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms+")\n",
"(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms2+")\n")
addDumpTest(nm, "(*"+mt+")(<nil>)\n")
addDumpTest(nilMap, "("+mt+") <nil>\n")
// Map with custom formatter type on pointer receiver only keys and vals.
k2 := pstringer("one")
v2 := pstringer("1")
m2 := map[pstringer]pstringer{k2: v2}
k2Len := fmt.Sprintf("%d", len(k2))
v2Len := fmt.Sprintf("%d", len(v2))
m2Len := fmt.Sprintf("%d", len(m2))
nilMap2 := map[pstringer]pstringer(nil)
nm2 := (*map[pstringer]pstringer)(nil)
pm2 := &m2
m2Addr := fmt.Sprintf("%p", pm2)
pm2Addr := fmt.Sprintf("%p", &pm2)
m2t := "map[spew_test.pstringer]spew_test.pstringer"
m2t1 := "spew_test.pstringer"
m2t2 := "spew_test.pstringer"
m2s := "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len + ") " +
"stringer one: (" + m2t2 + ") (len=" + v2Len + ") stringer 1\n}"
if spew.UnsafeDisabled {
m2s = "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len +
") " + "\"one\": (" + m2t2 + ") (len=" + v2Len +
") \"1\"\n}"
}
addDumpTest(m2, "("+m2t+") "+m2s+"\n")
addDumpTest(pm2, "(*"+m2t+")("+m2Addr+")("+m2s+")\n")
addDumpTest(&pm2, "(**"+m2t+")("+pm2Addr+"->"+m2Addr+")("+m2s+")\n")
addDumpTest(nm2, "(*"+m2t+")(<nil>)\n")
addDumpTest(nilMap2, "("+m2t+") <nil>\n")
// Map with interface keys and values.
k3 := "one"
k3Len := fmt.Sprintf("%d", len(k3))
m3 := map[interface{}]interface{}{k3: 1}
m3Len := fmt.Sprintf("%d", len(m3))
nilMap3 := map[interface{}]interface{}(nil)
nm3 := (*map[interface{}]interface{})(nil)
pm3 := &m3
m3Addr := fmt.Sprintf("%p", pm3)
pm3Addr := fmt.Sprintf("%p", &pm3)
m3t := "map[interface {}]interface {}"
m3t1 := "string"
m3t2 := "int"
m3s := "(len=" + m3Len + ") {\n (" + m3t1 + ") (len=" + k3Len + ") " +
"\"one\": (" + m3t2 + ") 1\n}"
addDumpTest(m3, "("+m3t+") "+m3s+"\n")
addDumpTest(pm3, "(*"+m3t+")("+m3Addr+")("+m3s+")\n")
addDumpTest(&pm3, "(**"+m3t+")("+pm3Addr+"->"+m3Addr+")("+m3s+")\n")
addDumpTest(nm3, "(*"+m3t+")(<nil>)\n")
addDumpTest(nilMap3, "("+m3t+") <nil>\n")
// Map with nil interface value.
k4 := "nil"
k4Len := fmt.Sprintf("%d", len(k4))
m4 := map[string]interface{}{k4: nil}
m4Len := fmt.Sprintf("%d", len(m4))
nilMap4 := map[string]interface{}(nil)
nm4 := (*map[string]interface{})(nil)
pm4 := &m4
m4Addr := fmt.Sprintf("%p", pm4)
pm4Addr := fmt.Sprintf("%p", &pm4)
m4t := "map[string]interface {}"
m4t1 := "string"
m4t2 := "interface {}"
m4s := "(len=" + m4Len + ") {\n (" + m4t1 + ") (len=" + k4Len + ")" +
" \"nil\": (" + m4t2 + ") <nil>\n}"
addDumpTest(m4, "("+m4t+") "+m4s+"\n")
addDumpTest(pm4, "(*"+m4t+")("+m4Addr+")("+m4s+")\n")
addDumpTest(&pm4, "(**"+m4t+")("+pm4Addr+"->"+m4Addr+")("+m4s+")\n")
addDumpTest(nm4, "(*"+m4t+")(<nil>)\n")
addDumpTest(nilMap4, "("+m4t+") <nil>\n")
}
func addStructDumpTests() {
// Struct with primitives.
type s1 struct {
a int8
b uint8
}
v := s1{127, 255}
nv := (*s1)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.s1"
vt2 := "int8"
vt3 := "uint8"
vs := "{\n a: (" + vt2 + ") 127,\n b: (" + vt3 + ") 255\n}"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Struct that contains another struct.
type s2 struct {
s1 s1
b bool
}
v2 := s2{s1{127, 255}, true}
nv2 := (*s2)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.s2"
v2t2 := "spew_test.s1"
v2t3 := "int8"
v2t4 := "uint8"
v2t5 := "bool"
v2s := "{\n s1: (" + v2t2 + ") {\n a: (" + v2t3 + ") 127,\n b: (" +
v2t4 + ") 255\n },\n b: (" + v2t5 + ") true\n}"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
// Struct that contains custom type with Stringer pointer interface via both
// exported and unexported fields.
type s3 struct {
s pstringer
S pstringer
}
v3 := s3{"test", "test2"}
nv3 := (*s3)(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "spew_test.s3"
v3t2 := "spew_test.pstringer"
v3s := "{\n s: (" + v3t2 + ") (len=4) stringer test,\n S: (" + v3t2 +
") (len=5) stringer test2\n}"
v3sp := v3s
if spew.UnsafeDisabled {
v3s = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
v3t2 + ") (len=5) \"test2\"\n}"
v3sp = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
v3t2 + ") (len=5) stringer test2\n}"
}
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3sp+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3sp+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
// Struct that contains embedded struct and field to same struct.
e := embed{"embedstr"}
eLen := fmt.Sprintf("%d", len("embedstr"))
v4 := embedwrap{embed: &e, e: &e}
nv4 := (*embedwrap)(nil)
pv4 := &v4
eAddr := fmt.Sprintf("%p", &e)
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "spew_test.embedwrap"
v4t2 := "spew_test.embed"
v4t3 := "string"
v4s := "{\n embed: (*" + v4t2 + ")(" + eAddr + ")({\n a: (" + v4t3 +
") (len=" + eLen + ") \"embedstr\"\n }),\n e: (*" + v4t2 +
")(" + eAddr + ")({\n a: (" + v4t3 + ") (len=" + eLen + ")" +
" \"embedstr\"\n })\n}"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
}
func addUintptrDumpTests() {
// Null pointer.
v := uintptr(0)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "uintptr"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
// Address of real variable.
i := 1
v2 := uintptr(unsafe.Pointer(&i))
nv2 := (*uintptr)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uintptr"
v2s := fmt.Sprintf("%p", &i)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
}
func addUnsafePointerDumpTests() {
// Null pointer.
v := unsafe.Pointer(uintptr(0))
nv := (*unsafe.Pointer)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "unsafe.Pointer"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Address of real variable.
i := 1
v2 := unsafe.Pointer(&i)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "unsafe.Pointer"
v2s := fmt.Sprintf("%p", &i)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
}
func addChanDumpTests() {
// Nil channel.
var v chan int
pv := &v
nv := (*chan int)(nil)
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "chan int"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Real channel.
v2 := make(chan int)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "chan int"
v2s := fmt.Sprintf("%p", v2)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
}
func addFuncDumpTests() {
// Function with no params and no returns.
v := addIntDumpTests
nv := (*func())(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "func()"
vs := fmt.Sprintf("%p", v)
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
// Function with param and no returns.
v2 := TestDump
nv2 := (*func(*testing.T))(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "func(*testing.T)"
v2s := fmt.Sprintf("%p", v2)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
// Function with multiple params and multiple returns.
var v3 = func(i int, s string) (b bool, err error) {
return true, nil
}
nv3 := (*func(int, string) (bool, error))(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "func(int, string) (bool, error)"
v3s := fmt.Sprintf("%p", v3)
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
}
func addCircularDumpTests() {
// Struct that is circular through self referencing.
type circular struct {
c *circular
}
v := circular{nil}
v.c = &v
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.circular"
vs := "{\n c: (*" + vt + ")(" + vAddr + ")({\n c: (*" + vt + ")(" +
vAddr + ")(<already shown>)\n })\n}"
vs2 := "{\n c: (*" + vt + ")(" + vAddr + ")(<already shown>)\n}"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs2+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs2+")\n")
// Structs that are circular through cross referencing.
v2 := xref1{nil}
ts2 := xref2{&v2}
v2.ps2 = &ts2
pv2 := &v2
ts2Addr := fmt.Sprintf("%p", &ts2)
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.xref1"
v2t2 := "spew_test.xref2"
v2s := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
")(" + v2Addr + ")({\n ps2: (*" + v2t2 + ")(" + ts2Addr +
")(<already shown>)\n })\n })\n}"
v2s2 := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
")(" + v2Addr + ")(<already shown>)\n })\n}"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s2+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s2+")\n")
// Structs that are indirectly circular.
v3 := indirCir1{nil}
tic2 := indirCir2{nil}
tic3 := indirCir3{&v3}
tic2.ps3 = &tic3
v3.ps2 = &tic2
pv3 := &v3
tic2Addr := fmt.Sprintf("%p", &tic2)
tic3Addr := fmt.Sprintf("%p", &tic3)
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "spew_test.indirCir1"
v3t2 := "spew_test.indirCir2"
v3t3 := "spew_test.indirCir3"
v3s := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
")({\n ps2: (*" + v3t2 + ")(" + tic2Addr +
")(<already shown>)\n })\n })\n })\n}"
v3s2 := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
")(<already shown>)\n })\n })\n}"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s2+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s2+")\n")
}
func addPanicDumpTests() {
// Type that panics in its Stringer interface.
v := panicer(127)
nv := (*panicer)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.panicer"
vs := "(PANIC=test panic)127"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
}
func addErrorDumpTests() {
// Type that has a custom Error interface.
v := customError(127)
nv := (*customError)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.customError"
vs := "error: 127"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
}
// TestDump executes all of the tests described by dumpTests.
func TestDump(t *testing.T) {
// Setup tests.
addIntDumpTests()
addUintDumpTests()
addBoolDumpTests()
addFloatDumpTests()
addComplexDumpTests()
addArrayDumpTests()
addSliceDumpTests()
addStringDumpTests()
addInterfaceDumpTests()
addMapDumpTests()
addStructDumpTests()
addUintptrDumpTests()
addUnsafePointerDumpTests()
addChanDumpTests()
addFuncDumpTests()
addCircularDumpTests()
addPanicDumpTests()
addErrorDumpTests()
addCgoDumpTests()
t.Logf("Running %d tests", len(dumpTests))
for i, test := range dumpTests {
buf := new(bytes.Buffer)
spew.Fdump(buf, test.in)
s := buf.String()
if testFailed(s, test.wants) {
t.Errorf("Dump #%d\n got: %s %s", i, s, stringizeWants(test.wants))
continue
}
}
}
func TestDumpSortedKeys(t *testing.T) {
cfg := spew.ConfigState{SortKeys: true}
s := cfg.Sdump(map[int]string{1: "1", 3: "3", 2: "2"})
expected := "(map[int]string) (len=3) {\n(int) 1: (string) (len=1) " +
"\"1\",\n(int) 2: (string) (len=1) \"2\",\n(int) 3: (string) " +
"(len=1) \"3\"\n" +
"}\n"
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
s = cfg.Sdump(map[stringer]int{"1": 1, "3": 3, "2": 2})
expected = "(map[spew_test.stringer]int) (len=3) {\n" +
"(spew_test.stringer) (len=1) stringer 1: (int) 1,\n" +
"(spew_test.stringer) (len=1) stringer 2: (int) 2,\n" +
"(spew_test.stringer) (len=1) stringer 3: (int) 3\n" +
"}\n"
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
s = cfg.Sdump(map[pstringer]int{pstringer("1"): 1, pstringer("3"): 3, pstringer("2"): 2})
expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
"(spew_test.pstringer) (len=1) stringer 1: (int) 1,\n" +
"(spew_test.pstringer) (len=1) stringer 2: (int) 2,\n" +
"(spew_test.pstringer) (len=1) stringer 3: (int) 3\n" +
"}\n"
if spew.UnsafeDisabled {
expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
"(spew_test.pstringer) (len=1) \"1\": (int) 1,\n" +
"(spew_test.pstringer) (len=1) \"2\": (int) 2,\n" +
"(spew_test.pstringer) (len=1) \"3\": (int) 3\n" +
"}\n"
}
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
s = cfg.Sdump(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})
expected = "(map[spew_test.customError]int) (len=3) {\n" +
"(spew_test.customError) error: 1: (int) 1,\n" +
"(spew_test.customError) error: 2: (int) 2,\n" +
"(spew_test.customError) error: 3: (int) 3\n" +
"}\n"
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/dumpcgo_test.go
================================================
// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
// NOTE: Due to the following build constraints, this file will only be compiled
// when both cgo is supported and "-tags testcgo" is added to the go test
// command line. This means the cgo tests are only added (and hence run) when
// specifially requested. This configuration is used because spew itself
// does not require cgo to run even though it does handle certain cgo types
// specially. Rather than forcing all clients to require cgo and an external
// C compiler just to run the tests, this scheme makes them optional.
// +build cgo,testcgo
package spew_test
import (
"fmt"
"github.com/davecgh/go-spew/spew/testdata"
)
func addCgoDumpTests() {
// C char pointer.
v := testdata.GetCgoCharPointer()
nv := testdata.GetCgoNullCharPointer()
pv := &v
vcAddr := fmt.Sprintf("%p", v)
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "*testdata._Ctype_char"
vs := "116"
addDumpTest(v, "("+vt+")("+vcAddr+")("+vs+")\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+"->"+vcAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+"->"+vcAddr+")("+vs+")\n")
addDumpTest(nv, "("+vt+")(<nil>)\n")
// C char array.
v2, v2l, v2c := testdata.GetCgoCharArray()
v2Len := fmt.Sprintf("%d", v2l)
v2Cap := fmt.Sprintf("%d", v2c)
v2t := "[6]testdata._Ctype_char"
v2s := "(len=" + v2Len + " cap=" + v2Cap + ") " +
"{\n 00000000 74 65 73 74 32 00 " +
" |test2.|\n}"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
// C unsigned char array.
v3, v3l, v3c := testdata.GetCgoUnsignedCharArray()
v3Len := fmt.Sprintf("%d", v3l)
v3Cap := fmt.Sprintf("%d", v3c)
v3t := "[6]testdata._Ctype_unsignedchar"
v3t2 := "[6]testdata._Ctype_uchar"
v3s := "(len=" + v3Len + " cap=" + v3Cap + ") " +
"{\n 00000000 74 65 73 74 33 00 " +
" |test3.|\n}"
addDumpTest(v3, "("+v3t+") "+v3s+"\n", "("+v3t2+") "+v3s+"\n")
// C signed char array.
v4, v4l, v4c := testdata.GetCgoSignedCharArray()
v4Len := fmt.Sprintf("%d", v4l)
v4Cap := fmt.Sprintf("%d", v4c)
v4t := "[6]testdata._Ctype_schar"
v4t2 := "testdata._Ctype_schar"
v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
"{\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 101,\n (" + v4t2 +
") 115,\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 52,\n (" + v4t2 +
") 0\n}"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
// C uint8_t array.
v5, v5l, v5c := testdata.GetCgoUint8tArray()
v5Len := fmt.Sprintf("%d", v5l)
v5Cap := fmt.Sprintf("%d", v5c)
v5t := "[6]testdata._Ctype_uint8_t"
v5s := "(len=" + v5Len + " cap=" + v5Cap + ") " +
"{\n 00000000 74 65 73 74 35 00 " +
" |test5.|\n}"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
// C typedefed unsigned char array.
v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
v6Len := fmt.Sprintf("%d", v6l)
v6Cap := fmt.Sprintf("%d", v6c)
v6t := "[6]testdata._Ctype_custom_uchar_t"
v6s := "(len=" + v6Len + " cap=" + v6Cap + ") " +
"{\n 00000000 74 65 73 74 36 00 " +
" |test6.|\n}"
addDumpTest(v6, "("+v6t+") "+v6s+"\n")
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
================================================
// Copyright (c) 2013 Dave Collins <dave@davec.name>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
// NOTE: Due to the following build constraints, this file will only be compiled
// when either cgo is not supported or "-tags testcgo" is not added to the go
// test command line. This file intentionally does not setup any cgo tests in
// this scenario.
// +build !cgo !testcgo
package spew_test
func addCgoDumpTests() {
// Don't add any tests for cgo since this file is only compiled when
// there should not be any cgo tests.
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/example_test.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew_test
import (
"fmt"
"github.com/davecgh/go-spew/spew"
)
type Flag int
const (
flagOne Flag = iota
flagTwo
)
var flagStrings = map[Flag]string{
flagOne: "flagOne",
flagTwo: "flagTwo",
}
func (f Flag) String() string {
if s, ok := flagStrings[f]; ok {
return s
}
return fmt.Sprintf("Unknown flag (%d)", int(f))
}
type Bar struct {
data uintptr
}
type Foo struct {
unexportedField Bar
ExportedField map[interface{}]interface{}
}
// This example demonstrates how to use Dump to dump variables to stdout.
func ExampleDump() {
// The following package level declarations are assumed for this example:
/*
type Flag int
const (
flagOne Flag = iota
flagTwo
)
var flagStrings = map[Flag]string{
flagOne: "flagOne",
flagTwo: "flagTwo",
}
func (f Flag) String() string {
if s, ok := flagStrings[f]; ok {
return s
}
return fmt.Sprintf("Unknown flag (%d)", int(f))
}
type Bar struct {
data uintptr
}
type Foo struct {
unexportedField Bar
ExportedField map[interface{}]interface{}
}
*/
// Setup some sample data structures for the example.
bar := Bar{uintptr(0)}
s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
f := Flag(5)
b := []byte{
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32,
}
// Dump!
spew.Dump(s1, f, b)
// Output:
// (spew_test.Foo) {
// unexportedField: (spew_test.Bar) {
// data: (uintptr) <nil>
// },
// ExportedField: (map[interface {}]interface {}) (len=1) {
// (string) (len=3) "one": (bool) true
// }
// }
// (spew_test.Flag) Unknown flag (5)
// ([]uint8) (len=34 cap=34) {
// 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
// 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
// 00000020 31 32 |12|
// }
//
}
// This example demonstrates how to use Printf to display a variable with a
// format string and inline formatting.
func ExamplePrintf() {
// Create a double pointer to a uint 8.
ui8 := uint8(5)
pui8 := &ui8
ppui8 := &pui8
// Create a circular data type.
type circular struct {
ui8 uint8
c *circular
}
c := circular{ui8: 1}
c.c = &c
// Print!
spew.Printf("ppui8: %v\n", ppui8)
spew.Printf("circular: %v\n", c)
// Output:
// ppui8: <**>5
// circular: {1 <*>{1 <*><shown>}}
}
// This example demonstrates how to use a ConfigState.
func ExampleConfigState() {
// Modify the indent level of the ConfigState only. The global
// configuration is not modified.
scs := spew.ConfigState{Indent: "\t"}
// Output using the ConfigState instance.
v := map[string]int{"one": 1}
scs.Printf("v: %v\n", v)
scs.Dump(v)
// Output:
// v: map[one:1]
// (map[string]int) (len=1) {
// (string) (len=3) "one": (int) 1
// }
}
// This example demonstrates how to use ConfigState.Dump to dump variables to
// stdout
func ExampleConfigState_Dump() {
// See the top-level Dump example for details on the types used in this
// example.
// Create two ConfigState instances with different indentation.
scs := spew.ConfigState{Indent: "\t"}
scs2 := spew.ConfigState{Indent: " "}
// Setup some sample data structures for the example.
bar := Bar{uintptr(0)}
s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
// Dump using the ConfigState instances.
scs.Dump(s1)
scs2.Dump(s1)
// Output:
// (spew_test.Foo) {
// unexportedField: (spew_test.Bar) {
// data: (uintptr) <nil>
// },
// ExportedField: (map[interface {}]interface {}) (len=1) {
// (string) (len=3) "one": (bool) true
// }
// }
// (spew_test.Foo) {
// unexportedField: (spew_test.Bar) {
// data: (uintptr) <nil>
// },
// ExportedField: (map[interface {}]interface {}) (len=1) {
// (string) (len=3) "one": (bool) true
// }
// }
//
}
// This example demonstrates how to use ConfigState.Printf to display a variable
// with a format string and inline formatting.
func ExampleConfigState_Printf() {
// See the top-level Dump example for details on the types used in this
// example.
// Create two ConfigState instances and modify the method handling of the
// first ConfigState only.
scs := spew.NewDefaultConfig()
scs2 := spew.NewDefaultConfig()
scs.DisableMethods = true
// Alternatively
// scs := spew.ConfigState{Indent: " ", DisableMethods: true}
// scs2 := spew.ConfigState{Indent: " "}
// This is of type Flag which implements a Stringer and has raw value 1.
f := flagTwo
// Dump using the ConfigState instances.
scs.Printf("f: %v\n", f)
scs2.Printf("f: %v\n", f)
// Output:
// f: 1
// f: flagTwo
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/format.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"fmt"
"reflect"
"strconv"
"strings"
)
// supportedFlags is a list of all the character flags supported by fmt package.
const supportedFlags = "0-+# "
// formatState implements the fmt.Formatter interface and contains information
// about the state of a formatting operation. The NewFormatter function can
// be used to get a new Formatter which can be used directly as arguments
// in standard fmt package printing calls.
type formatState struct {
value interface{}
fs fmt.State
depth int
pointers map[uintptr]int
ignoreNextType bool
cs *ConfigState
}
// buildDefaultFormat recreates the original format string without precision
// and width information to pass in to fmt.Sprintf in the case of an
// unrecognized type. Unless new types are added to the language, this
// function won't ever be called.
func (f *formatState) buildDefaultFormat() (format string) {
buf := bytes.NewBuffer(percentBytes)
for _, flag := range supportedFlags {
if f.fs.Flag(int(flag)) {
buf.WriteRune(flag)
}
}
buf.WriteRune('v')
format = buf.String()
return format
}
// constructOrigFormat recreates the original format string including precision
// and width information to pass along to the standard fmt package. This allows
// automatic deferral of all format strings this package doesn't support.
func (f *formatState) constructOrigFormat(verb rune) (format string) {
buf := bytes.NewBuffer(percentBytes)
for _, flag := range supportedFlags {
if f.fs.Flag(int(flag)) {
buf.WriteRune(flag)
}
}
if width, ok := f.fs.Width(); ok {
buf.WriteString(strconv.Itoa(width))
}
if precision, ok := f.fs.Precision(); ok {
buf.Write(precisionBytes)
buf.WriteString(strconv.Itoa(precision))
}
buf.WriteRune(verb)
format = buf.String()
return format
}
// unpackValue returns values inside of non-nil interfaces when possible and
// ensures that types for values which have been unpacked from an interface
// are displayed when the show types flag is also set.
// This is useful for data types like structs, arrays, slices, and maps which
// can contain varying types packed inside an interface.
func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Interface {
f.ignoreNextType = false
if !v.IsNil() {
v = v.Elem()
}
}
return v
}
// formatPtr handles formatting of pointers by indirecting them as necessary.
func (f *formatState) formatPtr(v reflect.Value) {
// Display nil if top level pointer is nil.
showTypes := f.fs.Flag('#')
if v.IsNil() && (!showTypes || f.ignoreNextType) {
f.fs.Write(nilAngleBytes)
return
}
// Remove pointers at or below the current depth from map used to detect
// circular refs.
for k, depth := range f.pointers {
if depth >= f.depth {
delete(f.pointers, k)
}
}
// Keep list of all dereferenced pointers to possibly show later.
pointerChain := make([]uintptr, 0)
// Figure out how many levels of indirection there are by derferencing
// pointers and unpacking interfaces down the chain while detecting circular
// references.
nilFound := false
cycleFound := false
indirects := 0
ve := v
for ve.Kind() == reflect.Ptr {
if ve.IsNil() {
nilFound = true
break
}
indirects++
addr := ve.Pointer()
pointerChain = append(pointerChain, addr)
if pd, ok := f.pointers[addr]; ok && pd < f.depth {
cycleFound = true
indirects--
break
}
f.pointers[addr] = f.depth
ve = ve.Elem()
if ve.Kind() == reflect.Interface {
if ve.IsNil() {
nilFound = true
break
}
ve = ve.Elem()
}
}
// Display type or indirection level depending on flags.
if showTypes && !f.ignoreNextType {
f.fs.Write(openParenBytes)
f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
f.fs.Write([]byte(ve.Type().String()))
f.fs.Write(closeParenBytes)
} else {
if nilFound || cycleFound {
indirects += strings.Count(ve.Type().String(), "*")
}
f.fs.Write(openAngleBytes)
f.fs.Write([]byte(strings.Repeat("*", indirects)))
f.fs.Write(closeAngleBytes)
}
// Display pointer information depending on flags.
if f.fs.Flag('+') && (len(pointerChain) > 0) {
f.fs.Write(openParenBytes)
for i, addr := range pointerChain {
if i > 0 {
f.fs.Write(pointerChainBytes)
}
printHexPtr(f.fs, addr)
}
f.fs.Write(closeParenBytes)
}
// Display dereferenced value.
switch {
case nilFound == true:
f.fs.Write(nilAngleBytes)
case cycleFound == true:
f.fs.Write(circularShortBytes)
default:
f.ignoreNextType = true
f.format(ve)
}
}
// format is the main workhorse for providing the Formatter interface. It
// uses the passed reflect value to figure out what kind of object we are
// dealing with and formats it appropriately. It is a recursive function,
// however circular data structures are detected and handled properly.
func (f *formatState) format(v reflect.Value) {
// Handle invalid reflect values immediately.
kind := v.Kind()
if kind == reflect.Invalid {
f.fs.Write(invalidAngleBytes)
return
}
// Handle pointers specially.
if kind == reflect.Ptr {
f.formatPtr(v)
return
}
// Print type information unless already handled elsewhere.
if !f.ignoreNextType && f.fs.Flag('#') {
f.fs.Write(openParenBytes)
f.fs.Write([]byte(v.Type().String()))
f.fs.Write(closeParenBytes)
}
f.ignoreNextType = false
// Call Stringer/error interfaces if they exist and the handle methods
// flag is enabled.
if !f.cs.DisableMethods {
if (kind != reflect.Invalid) && (kind != reflect.Interface) {
if handled := handleMethods(f.cs, f.fs, v); handled {
return
}
}
}
switch kind {
case reflect.Invalid:
// Do nothing. We should never get here since invalid has already
// been handled above.
case reflect.Bool:
printBool(f.fs, v.Bool())
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
printInt(f.fs, v.Int(), 10)
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
printUint(f.fs, v.Uint(), 10)
case reflect.Float32:
printFloat(f.fs, v.Float(), 32)
case reflect.Float64:
printFloat(f.fs, v.Float(), 64)
case reflect.Complex64:
printComplex(f.fs, v.Complex(), 32)
case reflect.Complex128:
printComplex(f.fs, v.Complex(), 64)
case reflect.Slice:
if v.IsNil() {
f.fs.Write(nilAngleBytes)
break
}
fallthrough
case reflect.Array:
f.fs.Write(openBracketBytes)
f.depth++
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
f.fs.Write(maxShortBytes)
} else {
numEntries := v.Len()
for i := 0; i < numEntries; i++ {
if i > 0 {
f.fs.Write(spaceBytes)
}
f.ignoreNextType = true
f.format(f.unpackValue(v.Index(i)))
}
}
f.depth--
f.fs.Write(closeBracketBytes)
case reflect.String:
f.fs.Write([]byte(v.String()))
case reflect.Interface:
// The only time we should get here is for nil interfaces due to
// unpackValue calls.
if v.IsNil() {
f.fs.Write(nilAngleBytes)
}
case reflect.Ptr:
// Do nothing. We should never get here since pointers have already
// been handled above.
case reflect.Map:
// nil maps should be indicated as different than empty maps
if v.IsNil() {
f.fs.Write(nilAngleBytes)
break
}
f.fs.Write(openMapBytes)
f.depth++
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
f.fs.Write(maxShortBytes)
} else {
keys := v.MapKeys()
if f.cs.SortKeys {
sortValues(keys, f.cs)
}
for i, key := range keys {
if i > 0 {
f.fs.Write(spaceBytes)
}
f.ignoreNextType = true
f.format(f.unpackValue(key))
f.fs.Write(colonBytes)
f.ignoreNextType = true
f.format(f.unpackValue(v.MapIndex(key)))
}
}
f.depth--
f.fs.Write(closeMapBytes)
case reflect.Struct:
numFields := v.NumField()
f.fs.Write(openBraceBytes)
f.depth++
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
f.fs.Write(maxShortBytes)
} else {
vt := v.Type()
for i := 0; i < numFields; i++ {
if i > 0 {
f.fs.Write(spaceBytes)
}
vtf := vt.Field(i)
if f.fs.Flag('+') || f.fs.Flag('#') {
f.fs.Write([]byte(vtf.Name))
f.fs.Write(colonBytes)
}
f.format(f.unpackValue(v.Field(i)))
}
}
f.depth--
f.fs.Write(closeBraceBytes)
case reflect.Uintptr:
printHexPtr(f.fs, uintptr(v.Uint()))
case reflect.UnsafePointer, reflect.Chan, reflect.Func:
printHexPtr(f.fs, v.Pointer())
// There were not any other types at the time this code was written, but
// fall back to letting the default fmt package handle it if any get added.
default:
format := f.buildDefaultFormat()
if v.CanInterface() {
fmt.Fprintf(f.fs, format, v.Interface())
} else {
fmt.Fprintf(f.fs, format, v.String())
}
}
}
// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
// details.
func (f *formatState) Format(fs fmt.State, verb rune) {
f.fs = fs
// Use standard formatting for verbs that are not v.
if verb != 'v' {
format := f.constructOrigFormat(verb)
fmt.Fprintf(fs, format, f.value)
return
}
if f.value == nil {
if fs.Flag('#') {
fs.Write(interfaceBytes)
}
fs.Write(nilAngleBytes)
return
}
f.format(reflect.ValueOf(f.value))
}
// newFormatter is a helper function to consolidate the logic from the various
// public methods which take varying config states.
func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
fs := &formatState{value: v, cs: cs}
fs.pointers = make(map[uintptr]int)
return fs
}
/*
NewFormatter returns a custom formatter that satisfies the fmt.Formatter
interface. As a result, it integrates cleanly with standard fmt package
printing functions. The formatter is useful for inline printing of smaller data
types similar to the standard %v format specifier.
The custom formatter only responds to the %v (most compact), %+v (adds pointer
addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
combinations. Any other verbs such as %x and %q will be sent to the the
standard fmt package for formatting. In addition, the custom formatter ignores
the width and precision arguments (however they will still work on the format
specifiers not handled by the custom formatter).
Typically this function shouldn't be called directly. It is much easier to make
use of the custom formatter by calling one of the convenience functions such as
Printf, Println, or Fprintf.
*/
func NewFormatter(v interface{}) fmt.Formatter {
return newFormatter(&Config, v)
}
================================================
FILE: vendor/github.com/davecgh/go-spew/spew/format_test.go
================================================
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
Test Summary:
NOTE: For each test, a nil pointer, a single pointer and double pointer to the
base test element are also tested to ensure proper indirection across all types.
- Max int8, int16, int32, int64, int
- Max uint8, uint16, uint32, uint64, uint
- Boolean true and false
- Standard complex64 and complex128
- Array containing standard ints
- Array containing type with custom formatter on pointer receiver only
- Array containing interfaces
- Slice containing standard float32 values
- Slice containing type with custom formatter on pointer receiver only
- Slice containing interfaces
- Nil slice
- Standard string
- Nil interface
- Sub-interface
- Map with string keys and int vals
- Map with custom formatter type on pointer receiver only keys and vals
- Map with interface keys and values
- Map with nil interface value
- Struct with primitives
- Struct that contains another struct
- Struct that contains custom type with Stringer pointer interface via both
exported and unexported fields
- Struct that contains embedded struct and field to same struct
- Uintptr to 0 (null pointer)
- Uintptr address of real variable
- Unsafe.Pointer to 0 (null pointer)
- Unsafe.Pointer to address of real variable
- Nil channel
- Standard int channel
- Function with no params and no returns
- Function with param and no returns
- Function with multiple params and multiple returns
- Struct that is circular through self referencing
- Structs that are circular through cross referencing
- Structs that are indirectly circular
- Type that panics in its Stringer interface
- Type that has a custom Error interface
- %x passthrough with uint
- %#x passthrough with uint
- %f passthrough with precision
- %f passthrough with width and precision
- %d passthrough with width
- %q passthrough with string
*/
package spew_test
import (
"bytes"
"fmt"
"testing"
"unsafe"
"github.com/davecgh/go-spew/spew"
)
// formatterTest is used to describe a test to be performed against NewFormatter.
type formatterTest struct {
format string
in interface{}
wants []string
}
// formatterTests houses all of the tests to be performed against NewFormatter.
var formatterTests = make([]formatterTest, 0)
// addFormatterTest is a helper method to append the passed input and desired
// result to formatterTests.
func addFormatterTest(format string, in interface{}, wants ...string) {
test := formatterTest{format, in, wants}
formatterTests = append(formatterTests, test)
}
func addIntFormatterTests() {
// Max int8.
v := int8(127)
nv := (*int8)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "int8"
vs := "127"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%#v", v, "("+vt+")"+vs)
addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
addFormatterTest("%#+v", v, "("+vt+")"+vs)
addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
// Max int16.
v2 := int16(32767)
nv2 := (*int16)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "int16"
v2s := "32767"
addFormatterTest("%v", v2, v2s)
addFormatterTest("%v", pv2, "<*>"+v2s)
addFormatterTest("%v", &pv2, "<**>"+v2s)
addFormatterTest("%v", nv2, "<nil>")
addFormatterTest("%+v", v2, v2s)
addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
// Max int32.
v3 := int32(2147483647)
nv3 := (*int32)(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "int32"
v3s := "2147483647"
addFormatterTest("%v", v3, v3s)
addFormatterTest("%v", pv3, "<*>"+v3s)
addFormatterTest("%v", &pv3, "<**>"+v3s)
addFormatterTest("%v", nv3, "<nil>")
addFormatterTest("%+v", v3, v3s)
addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
addFormatterTest("%+v", nv3, "<nil>")
addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
// Max int64.
v4 := int64(9223372036854775807)
nv4 := (*int64)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "int64"
v4s := "9223372036854775807"
addFormatterTest("%v", v4, v4s)
addFormatterTest("%v", pv4, "<*>"+v4s)
addFormatterTest("%v", &pv4, "<**>"+v4s)
addFormatterTest("%v", nv4, "<nil>")
addFormatterTest("%+v", v4, v4s)
addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
addFormatterTest("%+v", nv4, "<nil>")
addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
// Max int.
v5 := int(2147483647)
nv5 := (*int)(nil)
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "int"
v5s := "2147483647"
addFormatterTest("%v", v5, v5s)
addFormatterTest("%v", pv5, "<*>"+v5s)
addFormatterTest("%v", &pv5, "<**>"+v5s)
addFormatterTest("%v", nv5, "<nil>")
addFormatterTest("%+v", v5, v5s)
addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
addFormatterTest("%+v", nv5, "<nil>")
addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
addFormatterTest("%#+v", nv5, "(*"+v5t+")"+"<nil>")
}
func addUintFormatterTests() {
// Max uint8.
v := uint8(255)
nv := (*uint8)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "uint8"
vs := "255"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%#v", v, "("+vt+")"+vs)
addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
addFormatterTest("%#+v", v, "("+vt+")"+vs)
addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
// Max uint16.
v2 := uint16(65535)
nv2 := (*uint16)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uint16"
v2s := "65535"
addFormatterTest("%v", v2, v2s)
addFormatterTest("%v", pv2, "<*>"+v2s)
addFormatterTest("%v", &pv2, "<**>"+v2s)
addFormatterTest("%v", nv2, "<nil>")
addFormatterTest("%+v", v2, v2s)
addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
// Max uint32.
v3 := uint32(4294967295)
nv3 := (*uint32)(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "uint32"
v3s := "4294967295"
addFormatterTest("%v", v3, v3s)
addFormatterTest("%v", pv3, "<*>"+v3s)
addFormatterTest("%v", &pv3, "<**>"+v3s)
addFormatterTest("%v", nv3, "<nil>")
addFormatterTest("%+v", v3, v3s)
addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
addFormatterTest("%+v", nv3, "<nil>")
addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
// Max uint64.
v4 := uint64(18446744073709551615)
nv4 := (*uint64)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "uint64"
v4s := "18446744073709551615"
addFormatterTest("%v", v4, v4s)
addFormatterTest("%v", pv4, "<*>"+v4s)
addFormatterTest("%v", &pv4, "<**>"+v4s)
addFormatterTest("%v", nv4, "<nil>")
addFormatterTest("%+v", v4, v4s)
addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
addFormatterTest("%+v", nv4, "<nil>")
addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
// Max uint.
v5 := uint(4294967295)
nv5 := (*uint)(nil)
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "uint"
v5s := "4294967295"
addFormatterTest("%v", v5, v5s)
addFormatterTest("%v", pv5, "<*>"+v5s)
addFormatterTest("%v", &pv5, "<**>"+v5s)
addFormatterTest("%v", nv5, "<nil>")
addFormatterTest("%+v", v5, v5s)
addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
addFormatterTest("%+v", nv5, "<nil>")
addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
}
func addBoolFormatterTests() {
// Boolean true.
v := bool(true)
nv := (*bool)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "bool"
vs := "true"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%#v", v, "("+vt+")"+vs)
addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
addFormatterTest("%#+v", v, "("+vt+")"+vs)
addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
// Boolean false.
v2 := bool(false)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "bool"
v2s := "false"
addFormatterTest("%v", v2, v2s)
addFormatterTest("%v", pv2, "<*>"+v2s)
addFormatterTest("%v", &pv2, "<**>"+v2s)
addFormatterTest("%+v", v2, v2s)
addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
}
func addFloatFormatterTests() {
// Standard float32.
v := float32(3.1415)
nv := (*float32)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "float32"
vs := "3.1415"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%#v", v, "("+vt+")"+vs)
addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
addFormatterTest("%#+v", v, "("+vt+")"+vs)
addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
// Standard float64.
v2 := float64(3.1415926)
nv2 := (*float64)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "float64"
v2s := "3.1415926"
addFormatterTest("%v", v2, v2s)
addFormatterTest("%v", pv2, "<*>"+v2s)
addFormatterTest("%v", &pv2, "<**>"+v2s)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%+v", v2, v2s)
addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
}
func addComplexFormatterTests() {
// Standard complex64.
v := complex(float32(6), -2)
nv := (*complex64)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "complex64"
vs := "(6-2i)"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%#v", v, "("+vt+")"+vs)
addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
addFormatterTest("%#+v", v, "("+vt+")"+vs)
addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
// Standard complex128.
v2 := complex(float64(-6), 2)
nv2 := (*complex128)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "complex128"
v2s := "(-6+2i)"
addFormatterTest("%v", v2, v2s)
addFormatterTest("%v", pv2, "<*>"+v2s)
addFormatterTest("%v", &pv2, "<**>"+v2s)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%+v", v2, v2s)
addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
}
func addArrayFormatterTests() {
// Array containing standard ints.
v := [3]int{1, 2, 3}
nv := (*[3]int)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "[3]int"
vs := "[1 2 3]"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%#v", v, "("+vt+")"+vs)
addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
addFormatterTest("%#+v", v, "("+vt+")"+vs)
addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
// Array containing type with custom formatter on pointer receiver only.
v2 := [3]pstringer{"1", "2", "3"}
nv2 := (*[3]pstringer)(nil)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "[3]spew_test.pstringer"
v2sp := "[stringer 1 stringer 2 stringer 3]"
v2s := v2sp
if spew.UnsafeDisabled {
v2s = "[1 2 3]"
}
addFormatterTest("%v", v2, v2s)
addFormatterTest("%v", pv2, "<*>"+v2sp)
addFormatterTest("%v", &pv2, "<**>"+v2sp)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%+v", v2, v2s)
addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2sp)
addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2sp)
addFormatterTest("%+v", nv2, "<nil>")
addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2sp)
addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2sp)
addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2sp)
addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2sp)
addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
// Array containing interfaces.
v3 := [3]interface{}{"one", int(2), uint(3)}
nv3 := (*[3]interface{})(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "[3]interface {}"
v3t2 := "string"
v3t3 := "int"
v3t4 := "uint"
v3s := "[one 2 3]"
v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3]"
addFormatterTest("%v", v3, v3s)
addFormatterTest("%v", pv3, "<*>"+v3s)
addFormatterTest("%v", &pv3, "<**>"+v3s)
addFormatterTest("%+v", nv3, "<nil>")
addFormatterTest("%+v", v3, v3s)
addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
addFormatterTest("%+v", nv3, "<nil>")
addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
}
func addSliceFormatterTests() {
// Slice containing standard float32 values.
v := []float32{3.14, 6.28, 12.56}
nv := (*[]float32)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "[]float32"
vs := "[3.14 6.28 12.56]"
addFormatterTest("%v", v, vs)
addFormatterTest("%v", pv, "<*>"+vs)
addFormatterTest("%v", &pv, "<**>"+vs)
addFormatterTest("%+v", nv, "<nil>")
addFormatterTest("%+v", v, vs)
addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
addFormatterTest("%
gitextract_vnb91kqq/ ├── .gitignore ├── .travis.yml ├── Dockerfile ├── Gopkg.toml ├── LICENSE.txt ├── README.md ├── goreleaser.yml ├── tools/ │ ├── README.md │ ├── change_metric_collection_level.py │ └── requirements.txt ├── vendor/ │ ├── github.com/ │ │ ├── davecgh/ │ │ │ └── go-spew/ │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── cov_report.sh │ │ │ ├── spew/ │ │ │ │ ├── bypass.go │ │ │ │ ├── bypasssafe.go │ │ │ │ ├── common.go │ │ │ │ ├── common_test.go │ │ │ │ ├── config.go │ │ │ │ ├── doc.go │ │ │ │ ├── dump.go │ │ │ │ ├── dump_test.go │ │ │ │ ├── dumpcgo_test.go │ │ │ │ ├── dumpnocgo_test.go │ │ │ │ ├── example_test.go │ │ │ │ ├── format.go │ │ │ │ ├── format_test.go │ │ │ │ ├── internal_test.go │ │ │ │ ├── internalunsafe_test.go │ │ │ │ ├── spew.go │ │ │ │ ├── spew_test.go │ │ │ │ └── testdata/ │ │ │ │ └── dumpcgo.go │ │ │ └── test_coverage.txt │ │ ├── influxdata/ │ │ │ └── influxdb/ │ │ │ ├── .dockerignore │ │ │ ├── .github/ │ │ │ │ ├── ISSUE_TEMPLATE.md │ │ │ │ └── PULL_REQUEST_TEMPLATE.md │ │ │ ├── .gitignore │ │ │ ├── .hooks/ │ │ │ │ └── pre-commit │ │ │ ├── .mention-bot │ │ │ ├── CHANGELOG.md │ │ │ ├── CODING_GUIDELINES.md │ │ │ ├── CONTRIBUTING.md │ │ │ ├── Dockerfile_build_ubuntu32 │ │ │ ├── Dockerfile_build_ubuntu64 │ │ │ ├── Dockerfile_build_ubuntu64_git │ │ │ ├── Dockerfile_test_ubuntu32 │ │ │ ├── Godeps │ │ │ ├── LICENSE │ │ │ ├── LICENSE_OF_DEPENDENCIES.md │ │ │ ├── Makefile │ │ │ ├── QUERIES.md │ │ │ ├── README.md │ │ │ ├── TODO.md │ │ │ ├── appveyor.yml │ │ │ ├── build.py │ │ │ ├── build.sh │ │ │ ├── circle-test.sh │ │ │ ├── circle.yml │ │ │ ├── client/ │ │ │ │ ├── README.md │ │ │ │ ├── example_test.go │ │ │ │ ├── influxdb.go │ │ │ │ ├── influxdb_test.go │ │ │ │ └── v2/ │ │ │ │ ├── client.go │ │ │ │ ├── client_test.go │ │ │ │ ├── example_test.go │ │ │ │ └── udp.go │ │ │ ├── cmd/ │ │ │ │ ├── influx/ │ │ │ │ │ ├── cli/ │ │ │ │ │ │ ├── cli.go │ │ │ │ │ │ ├── cli_internal_test.go │ │ │ │ │ │ ├── cli_test.go │ │ │ │ │ │ ├── parser.go │ │ │ │ │ │ └── parser_internal_test.go │ │ │ │ │ └── main.go │ │ │ │ ├── influx_stress/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── examples/ │ │ │ │ │ │ └── template.toml │ │ │ │ │ └── influx_stress.go │ │ │ │ ├── influx_tsm/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── b1/ │ │ │ │ │ │ └── reader.go │ │ │ │ │ ├── bz1/ │ │ │ │ │ │ └── reader.go │ │ │ │ │ ├── converter.go │ │ │ │ │ ├── main.go │ │ │ │ │ ├── stats/ │ │ │ │ │ │ └── stats.go │ │ │ │ │ ├── tracker.go │ │ │ │ │ └── tsdb/ │ │ │ │ │ ├── codec.go │ │ │ │ │ ├── database.go │ │ │ │ │ ├── internal/ │ │ │ │ │ │ └── meta.pb.go │ │ │ │ │ └── types.go │ │ │ │ ├── influxd/ │ │ │ │ │ ├── backup/ │ │ │ │ │ │ └── backup.go │ │ │ │ │ ├── help/ │ │ │ │ │ │ └── help.go │ │ │ │ │ ├── main.go │ │ │ │ │ ├── restore/ │ │ │ │ │ │ └── restore.go │ │ │ │ │ └── run/ │ │ │ │ │ ├── command.go │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_command.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ └── server.go │ │ │ │ └── parse.go │ │ │ ├── coordinator/ │ │ │ │ ├── config.go │ │ │ │ ├── config_test.go │ │ │ │ ├── meta_client.go │ │ │ │ ├── meta_client_test.go │ │ │ │ ├── points_writer.go │ │ │ │ ├── points_writer_internal_test.go │ │ │ │ ├── points_writer_test.go │ │ │ │ ├── shard_mapper.go │ │ │ │ ├── shard_mapper_test.go │ │ │ │ ├── statement_executor.go │ │ │ │ └── statement_executor_test.go │ │ │ ├── errors.go │ │ │ ├── etc/ │ │ │ │ ├── burn-in/ │ │ │ │ │ ├── .rvmrc │ │ │ │ │ ├── Gemfile │ │ │ │ │ ├── Gemfile.lock │ │ │ │ │ ├── burn-in.rb │ │ │ │ │ ├── log.rb │ │ │ │ │ ├── random_gaussian.rb │ │ │ │ │ └── random_points.rb │ │ │ │ └── config.sample.toml │ │ │ ├── gobuild.sh │ │ │ ├── importer/ │ │ │ │ ├── README.md │ │ │ │ └── v8/ │ │ │ │ └── importer.go │ │ │ ├── influxdb.go │ │ │ ├── influxql/ │ │ │ │ ├── README.md │ │ │ │ ├── ast.go │ │ │ │ ├── ast_test.go │ │ │ │ ├── call_iterator.go │ │ │ │ ├── call_iterator_test.go │ │ │ │ ├── cast.go │ │ │ │ ├── doc.go │ │ │ │ ├── emitter.go │ │ │ │ ├── emitter_test.go │ │ │ │ ├── functions.gen.go │ │ │ │ ├── functions.gen.go.tmpl │ │ │ │ ├── functions.go │ │ │ │ ├── functions_test.go │ │ │ │ ├── influxql.go │ │ │ │ ├── internal/ │ │ │ │ │ ├── internal.pb.go │ │ │ │ │ └── internal.proto │ │ │ │ ├── iterator.gen.go │ │ │ │ ├── iterator.gen.go.tmpl │ │ │ │ ├── iterator.go │ │ │ │ ├── iterator_mapper.go │ │ │ │ ├── iterator_mapper_test.go │ │ │ │ ├── iterator_test.go │ │ │ │ ├── linear.go │ │ │ │ ├── monitor.go │ │ │ │ ├── neldermead/ │ │ │ │ │ ├── neldermead.go │ │ │ │ │ └── neldermead_test.go │ │ │ │ ├── parser.go │ │ │ │ ├── parser_test.go │ │ │ │ ├── point.gen.go │ │ │ │ ├── point.gen.go.tmpl │ │ │ │ ├── point.go │ │ │ │ ├── point_test.go │ │ │ │ ├── query_executor.go │ │ │ │ ├── query_executor_test.go │ │ │ │ ├── result.go │ │ │ │ ├── sanitize.go │ │ │ │ ├── sanitize_test.go │ │ │ │ ├── scanner.go │ │ │ │ ├── scanner_test.go │ │ │ │ ├── select.go │ │ │ │ ├── select_test.go │ │ │ │ ├── statement_rewriter.go │ │ │ │ ├── statement_rewriter_test.go │ │ │ │ ├── subquery.go │ │ │ │ ├── task_manager.go │ │ │ │ ├── tmpldata │ │ │ │ └── token.go │ │ │ ├── internal/ │ │ │ │ └── meta_client.go │ │ │ ├── man/ │ │ │ │ ├── Makefile │ │ │ │ ├── README.md │ │ │ │ ├── footer.txt │ │ │ │ ├── influx.txt │ │ │ │ ├── influx_inspect.txt │ │ │ │ ├── influx_stress.txt │ │ │ │ ├── influx_tsm.txt │ │ │ │ ├── influxd-backup.txt │ │ │ │ ├── influxd-config.txt │ │ │ │ ├── influxd-restore.txt │ │ │ │ ├── influxd-run.txt │ │ │ │ ├── influxd-version.txt │ │ │ │ └── influxd.txt │ │ │ ├── models/ │ │ │ │ ├── consistency.go │ │ │ │ ├── inline_fnv.go │ │ │ │ ├── inline_fnv_test.go │ │ │ │ ├── inline_strconv_parse.go │ │ │ │ ├── inline_strconv_parse_test.go │ │ │ │ ├── points.go │ │ │ │ ├── points_internal_test.go │ │ │ │ ├── points_test.go │ │ │ │ ├── rows.go │ │ │ │ ├── statistic.go │ │ │ │ ├── statistic_test.go │ │ │ │ └── time.go │ │ │ ├── monitor/ │ │ │ │ ├── README.md │ │ │ │ ├── build_info.go │ │ │ │ ├── config.go │ │ │ │ ├── config_test.go │ │ │ │ ├── diagnostics/ │ │ │ │ │ └── diagnostics.go │ │ │ │ ├── go_runtime.go │ │ │ │ ├── network.go │ │ │ │ ├── reporter.go │ │ │ │ ├── service.go │ │ │ │ └── system.go │ │ │ ├── nightly.sh │ │ │ ├── node.go │ │ │ ├── pkg/ │ │ │ │ ├── README.md │ │ │ │ ├── bloom/ │ │ │ │ │ ├── bloom.go │ │ │ │ │ └── bloom_test.go │ │ │ │ ├── bytesutil/ │ │ │ │ │ └── bytesutil.go │ │ │ │ ├── deep/ │ │ │ │ │ └── equal.go │ │ │ │ ├── escape/ │ │ │ │ │ ├── bytes.go │ │ │ │ │ ├── bytes_test.go │ │ │ │ │ ├── strings.go │ │ │ │ │ └── strings_test.go │ │ │ │ ├── estimator/ │ │ │ │ │ ├── hll/ │ │ │ │ │ │ ├── compressed.go │ │ │ │ │ │ ├── empirical_data.go │ │ │ │ │ │ ├── hll.go │ │ │ │ │ │ └── hll_test.go │ │ │ │ │ └── sketch.go │ │ │ │ ├── limiter/ │ │ │ │ │ └── fixed.go │ │ │ │ ├── mmap/ │ │ │ │ │ ├── mmap_test.go │ │ │ │ │ ├── mmap_unix.go │ │ │ │ │ └── mmap_windows.go │ │ │ │ ├── pool/ │ │ │ │ │ ├── bytes.go │ │ │ │ │ ├── bytes_test.go │ │ │ │ │ └── generic.go │ │ │ │ ├── rhh/ │ │ │ │ │ ├── rhh.go │ │ │ │ │ └── rhh_test.go │ │ │ │ └── slices/ │ │ │ │ └── strings.go │ │ │ ├── releng/ │ │ │ │ ├── README.md │ │ │ │ ├── _go_versions.sh │ │ │ │ ├── raw-binaries/ │ │ │ │ │ ├── Dockerfile │ │ │ │ │ ├── build.bash │ │ │ │ │ └── fs/ │ │ │ │ │ └── usr/ │ │ │ │ │ └── local/ │ │ │ │ │ └── bin/ │ │ │ │ │ └── influxdb_raw_binaries.bash │ │ │ │ ├── source-tarball/ │ │ │ │ │ ├── Dockerfile │ │ │ │ │ ├── build.bash │ │ │ │ │ └── fs/ │ │ │ │ │ └── usr/ │ │ │ │ │ └── local/ │ │ │ │ │ └── bin/ │ │ │ │ │ └── influxdb_tarball.bash │ │ │ │ └── unit-tests/ │ │ │ │ ├── Dockerfile │ │ │ │ ├── fs/ │ │ │ │ │ └── usr/ │ │ │ │ │ └── local/ │ │ │ │ │ └── bin/ │ │ │ │ │ └── influxdb_prebuild_tests.bash │ │ │ │ └── run.bash │ │ │ ├── scripts/ │ │ │ │ ├── influxdb.service │ │ │ │ ├── init.sh │ │ │ │ ├── logrotate │ │ │ │ ├── post-install.sh │ │ │ │ ├── post-uninstall.sh │ │ │ │ └── pre-install.sh │ │ │ ├── services/ │ │ │ │ ├── collectd/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── collectd_test.conf │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── service.go │ │ │ │ │ ├── service_test.go │ │ │ │ │ └── test_client/ │ │ │ │ │ ├── README.md │ │ │ │ │ └── client.go │ │ │ │ ├── continuous_querier/ │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── continuous_queries.md │ │ │ │ │ ├── service.go │ │ │ │ │ └── service_test.go │ │ │ │ ├── graphite/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── parser.go │ │ │ │ │ ├── parser_test.go │ │ │ │ │ ├── service.go │ │ │ │ │ └── service_test.go │ │ │ │ ├── httpd/ │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── handler.go │ │ │ │ │ ├── handler_test.go │ │ │ │ │ ├── listen.go │ │ │ │ │ ├── listen_test.go │ │ │ │ │ ├── pprof.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── response_logger.go │ │ │ │ │ ├── response_writer.go │ │ │ │ │ ├── response_writer_test.go │ │ │ │ │ └── service.go │ │ │ │ ├── meta/ │ │ │ │ │ ├── client.go │ │ │ │ │ ├── client_test.go │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── data.go │ │ │ │ │ ├── data_internal_test.go │ │ │ │ │ ├── data_test.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── file_unix.go │ │ │ │ │ ├── file_windows.go │ │ │ │ │ ├── internal/ │ │ │ │ │ │ ├── meta.pb.go │ │ │ │ │ │ └── meta.proto │ │ │ │ │ ├── meta_test.go │ │ │ │ │ ├── query_authorizer.go │ │ │ │ │ └── write_authorizer.go │ │ │ │ ├── opentsdb/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── handler.go │ │ │ │ │ ├── service.go │ │ │ │ │ └── service_test.go │ │ │ │ ├── precreator/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── service.go │ │ │ │ │ └── service_test.go │ │ │ │ ├── retention/ │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ └── service.go │ │ │ │ ├── snapshotter/ │ │ │ │ │ ├── client.go │ │ │ │ │ ├── service.go │ │ │ │ │ └── service_test.go │ │ │ │ ├── subscriber/ │ │ │ │ │ ├── config.go │ │ │ │ │ ├── config_test.go │ │ │ │ │ ├── http.go │ │ │ │ │ ├── service.go │ │ │ │ │ ├── service_test.go │ │ │ │ │ └── udp.go │ │ │ │ └── udp/ │ │ │ │ ├── README.md │ │ │ │ ├── config.go │ │ │ │ ├── config_test.go │ │ │ │ ├── service.go │ │ │ │ └── service_test.go │ │ │ ├── stress/ │ │ │ │ ├── DESIGN.md │ │ │ │ ├── README.md │ │ │ │ ├── basic.go │ │ │ │ ├── config.go │ │ │ │ ├── run.go │ │ │ │ ├── stress.toml │ │ │ │ ├── stress_test.go │ │ │ │ ├── stress_test_server/ │ │ │ │ │ └── server.go │ │ │ │ ├── template.go │ │ │ │ ├── util.go │ │ │ │ └── v2/ │ │ │ │ ├── DESIGN.md │ │ │ │ ├── README.md │ │ │ │ ├── iql/ │ │ │ │ │ ├── default.iql │ │ │ │ │ └── file.iql │ │ │ │ ├── main.go │ │ │ │ ├── statement/ │ │ │ │ │ ├── exec.go │ │ │ │ │ ├── exec_test.go │ │ │ │ │ ├── function.go │ │ │ │ │ ├── function_test.go │ │ │ │ │ ├── go.go │ │ │ │ │ ├── go_test.go │ │ │ │ │ ├── influxql.go │ │ │ │ │ ├── influxql_test.go │ │ │ │ │ ├── insert.go │ │ │ │ │ ├── insert_test.go │ │ │ │ │ ├── query.go │ │ │ │ │ ├── query_test.go │ │ │ │ │ ├── report.go │ │ │ │ │ ├── report_test.go │ │ │ │ │ ├── response_time.go │ │ │ │ │ ├── response_time_test.go │ │ │ │ │ ├── set.go │ │ │ │ │ ├── set_test.go │ │ │ │ │ ├── statement.go │ │ │ │ │ ├── template.go │ │ │ │ │ ├── template_test.go │ │ │ │ │ ├── timestamp.go │ │ │ │ │ ├── timestamp_test.go │ │ │ │ │ ├── wait.go │ │ │ │ │ └── wait_test.go │ │ │ │ ├── stress_client/ │ │ │ │ │ ├── commune.go │ │ │ │ │ ├── commune_test.go │ │ │ │ │ ├── directive.go │ │ │ │ │ ├── directive_test.go │ │ │ │ │ ├── package.go │ │ │ │ │ ├── package_test.go │ │ │ │ │ ├── reporting.go │ │ │ │ │ ├── reporting_test.go │ │ │ │ │ ├── response.go │ │ │ │ │ ├── response_test.go │ │ │ │ │ ├── stressTest.go │ │ │ │ │ ├── stressTest_test.go │ │ │ │ │ ├── stress_client.go │ │ │ │ │ ├── stress_client_query.go │ │ │ │ │ ├── stress_client_write.go │ │ │ │ │ ├── tracer.go │ │ │ │ │ ├── tracer_test.go │ │ │ │ │ └── util.go │ │ │ │ └── stressql/ │ │ │ │ ├── parser.go │ │ │ │ ├── parser_test.go │ │ │ │ └── statement/ │ │ │ │ ├── parser.go │ │ │ │ └── parser_test.go │ │ │ ├── tcp/ │ │ │ │ ├── mux.go │ │ │ │ └── mux_test.go │ │ │ ├── test.sh │ │ │ ├── tests/ │ │ │ │ ├── README.md │ │ │ │ ├── backup_restore_test.go │ │ │ │ ├── server_bench_test.go │ │ │ │ ├── server_helpers.go │ │ │ │ ├── server_suite.go │ │ │ │ └── server_test.go │ │ │ ├── toml/ │ │ │ │ ├── toml.go │ │ │ │ └── toml_test.go │ │ │ ├── tsdb/ │ │ │ │ ├── README.md │ │ │ │ ├── batcher.go │ │ │ │ ├── batcher_test.go │ │ │ │ ├── config.go │ │ │ │ ├── config_test.go │ │ │ │ ├── cursor.go │ │ │ │ ├── doc.go │ │ │ │ ├── engine/ │ │ │ │ │ ├── engine.go │ │ │ │ │ └── tsm1/ │ │ │ │ │ ├── DESIGN.md │ │ │ │ │ ├── MANIFEST │ │ │ │ │ ├── bit_reader.go │ │ │ │ │ ├── bit_reader_test.go │ │ │ │ │ ├── bool.go │ │ │ │ │ ├── bool_test.go │ │ │ │ │ ├── cache.go │ │ │ │ │ ├── cache_race_test.go │ │ │ │ │ ├── cache_test.go │ │ │ │ │ ├── compact.gen.go │ │ │ │ │ ├── compact.gen.go.tmpl │ │ │ │ │ ├── compact.gen.go.tmpldata │ │ │ │ │ ├── compact.go │ │ │ │ │ ├── compact_test.go │ │ │ │ │ ├── cursor.go │ │ │ │ │ ├── encoding.gen.go │ │ │ │ │ ├── encoding.gen.go.tmpl │ │ │ │ │ ├── encoding.gen.go.tmpldata │ │ │ │ │ ├── encoding.go │ │ │ │ │ ├── encoding_test.go │ │ │ │ │ ├── engine.go │ │ │ │ │ ├── engine_test.go │ │ │ │ │ ├── file_store.gen.go │ │ │ │ │ ├── file_store.gen.go.tmpl │ │ │ │ │ ├── file_store.gen.go.tmpldata │ │ │ │ │ ├── file_store.go │ │ │ │ │ ├── file_store_internal_test.go │ │ │ │ │ ├── file_store_test.go │ │ │ │ │ ├── file_unix.go │ │ │ │ │ ├── file_windows.go │ │ │ │ │ ├── float.go │ │ │ │ │ ├── float_test.go │ │ │ │ │ ├── int.go │ │ │ │ │ ├── int_test.go │ │ │ │ │ ├── iterator.gen.go │ │ │ │ │ ├── iterator.gen.go.tmpl │ │ │ │ │ ├── iterator.gen.go.tmpldata │ │ │ │ │ ├── iterator.go │ │ │ │ │ ├── mmap_solaris.go │ │ │ │ │ ├── mmap_unix.go │ │ │ │ │ ├── mmap_windows.go │ │ │ │ │ ├── pools.go │ │ │ │ │ ├── reader.go │ │ │ │ │ ├── reader_test.go │ │ │ │ │ ├── ring.go │ │ │ │ │ ├── ring_test.go │ │ │ │ │ ├── string.go │ │ │ │ │ ├── string_test.go │ │ │ │ │ ├── timestamp.go │ │ │ │ │ ├── timestamp_test.go │ │ │ │ │ ├── tombstone.go │ │ │ │ │ ├── tombstone_test.go │ │ │ │ │ ├── wal.go │ │ │ │ │ ├── wal_test.go │ │ │ │ │ ├── writer.go │ │ │ │ │ └── writer_test.go │ │ │ │ ├── engine.go │ │ │ │ ├── index/ │ │ │ │ │ ├── index.go │ │ │ │ │ ├── inmem/ │ │ │ │ │ │ ├── inmem.go │ │ │ │ │ │ ├── meta.go │ │ │ │ │ │ └── meta_test.go │ │ │ │ │ ├── internal/ │ │ │ │ │ │ └── file_set.go │ │ │ │ │ └── tsi1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── file_set.go │ │ │ │ │ ├── file_set_test.go │ │ │ │ │ ├── index.go │ │ │ │ │ ├── index_file.go │ │ │ │ │ ├── index_file_test.go │ │ │ │ │ ├── index_files.go │ │ │ │ │ ├── index_files_test.go │ │ │ │ │ ├── index_test.go │ │ │ │ │ ├── log_file.go │ │ │ │ │ ├── log_file_test.go │ │ │ │ │ ├── measurement_block.go │ │ │ │ │ ├── measurement_block_test.go │ │ │ │ │ ├── series_block.go │ │ │ │ │ ├── series_block_test.go │ │ │ │ │ ├── tag_block.go │ │ │ │ │ ├── tag_block_test.go │ │ │ │ │ ├── tsi1.go │ │ │ │ │ └── tsi1_test.go │ │ │ │ ├── index.go │ │ │ │ ├── internal/ │ │ │ │ │ ├── meta.pb.go │ │ │ │ │ └── meta.proto │ │ │ │ ├── meta.go │ │ │ │ ├── meta_test.go │ │ │ │ ├── shard.go │ │ │ │ ├── shard_internal_test.go │ │ │ │ ├── shard_test.go │ │ │ │ ├── store.go │ │ │ │ ├── store_internal_test.go │ │ │ │ └── store_test.go │ │ │ └── uuid/ │ │ │ └── uuid.go │ │ └── vmware/ │ │ └── govmomi/ │ │ ├── .drone.sec │ │ ├── .drone.yml │ │ ├── .gitignore │ │ ├── .mailmap │ │ ├── .travis.yml │ │ ├── CHANGELOG.md │ │ ├── CONTRIBUTING.md │ │ ├── CONTRIBUTORS │ │ ├── LICENSE.txt │ │ ├── Makefile │ │ ├── README.md │ │ ├── client.go │ │ ├── client_test.go │ │ ├── event/ │ │ │ ├── history_collector.go │ │ │ ├── manager.go │ │ │ ├── processor.go │ │ │ └── sort.go │ │ ├── examples/ │ │ │ ├── datastores/ │ │ │ │ └── main.go │ │ │ ├── examples.go │ │ │ ├── hosts/ │ │ │ │ └── main.go │ │ │ ├── networks/ │ │ │ │ └── main.go │ │ │ └── virtualmachines/ │ │ │ └── main.go │ │ ├── find/ │ │ │ ├── doc.go │ │ │ ├── error.go │ │ │ ├── finder.go │ │ │ └── recurser.go │ │ ├── gen/ │ │ │ ├── Gemfile │ │ │ ├── gen.sh │ │ │ ├── gen_from_vmodl.rb │ │ │ ├── gen_from_wsdl.rb │ │ │ └── vim_wsdl.rb │ │ ├── govc/ │ │ │ ├── .gitignore │ │ │ ├── CHANGELOG.md │ │ │ ├── README.md │ │ │ ├── USAGE.md │ │ │ ├── about/ │ │ │ │ ├── cert.go │ │ │ │ └── command.go │ │ │ ├── build.sh │ │ │ ├── cli/ │ │ │ │ ├── command.go │ │ │ │ └── register.go │ │ │ ├── cluster/ │ │ │ │ ├── add.go │ │ │ │ ├── change.go │ │ │ │ └── create.go │ │ │ ├── datacenter/ │ │ │ │ ├── create.go │ │ │ │ └── info.go │ │ │ ├── datastore/ │ │ │ │ ├── cp.go │ │ │ │ ├── create.go │ │ │ │ ├── disk/ │ │ │ │ │ ├── create.go │ │ │ │ │ └── info.go │ │ │ │ ├── download.go │ │ │ │ ├── info.go │ │ │ │ ├── ls.go │ │ │ │ ├── mkdir.go │ │ │ │ ├── mv.go │ │ │ │ ├── remove.go │ │ │ │ ├── rm.go │ │ │ │ ├── tail.go │ │ │ │ ├── upload.go │ │ │ │ └── vsan/ │ │ │ │ ├── ls.go │ │ │ │ └── rm.go │ │ │ ├── device/ │ │ │ │ ├── boot.go │ │ │ │ ├── cdrom/ │ │ │ │ │ ├── add.go │ │ │ │ │ ├── eject.go │ │ │ │ │ └── insert.go │ │ │ │ ├── connect.go │ │ │ │ ├── disconnect.go │ │ │ │ ├── floppy/ │ │ │ │ │ ├── add.go │ │ │ │ │ ├── eject.go │ │ │ │ │ └── insert.go │ │ │ │ ├── info.go │ │ │ │ ├── ls.go │ │ │ │ ├── remove.go │ │ │ │ ├── scsi/ │ │ │ │ │ └── add.go │ │ │ │ ├── serial/ │ │ │ │ │ ├── add.go │ │ │ │ │ ├── connect.go │ │ │ │ │ └── disconnect.go │ │ │ │ └── usb/ │ │ │ │ └── add.go │ │ │ ├── dvs/ │ │ │ │ ├── add.go │ │ │ │ ├── create.go │ │ │ │ └── portgroup/ │ │ │ │ ├── add.go │ │ │ │ ├── change.go │ │ │ │ ├── info.go │ │ │ │ └── spec.go │ │ │ ├── emacs/ │ │ │ │ ├── .gitignore │ │ │ │ ├── Cask │ │ │ │ ├── Makefile │ │ │ │ ├── README.md │ │ │ │ ├── govc.el │ │ │ │ └── test/ │ │ │ │ ├── govc-test.el │ │ │ │ └── make.el │ │ │ ├── env/ │ │ │ │ └── command.go │ │ │ ├── events/ │ │ │ │ └── command.go │ │ │ ├── examples/ │ │ │ │ ├── lib/ │ │ │ │ │ └── ssh.sh │ │ │ │ └── vcsa.sh │ │ │ ├── extension/ │ │ │ │ ├── info.go │ │ │ │ ├── register.go │ │ │ │ ├── setcert.go │ │ │ │ └── unregister.go │ │ │ ├── fields/ │ │ │ │ ├── add.go │ │ │ │ ├── ls.go │ │ │ │ ├── rename.go │ │ │ │ ├── rm.go │ │ │ │ └── set.go │ │ │ ├── flags/ │ │ │ │ ├── client.go │ │ │ │ ├── common.go │ │ │ │ ├── datacenter.go │ │ │ │ ├── datastore.go │ │ │ │ ├── debug.go │ │ │ │ ├── empty.go │ │ │ │ ├── folder.go │ │ │ │ ├── host_connect.go │ │ │ │ ├── host_system.go │ │ │ │ ├── int32.go │ │ │ │ ├── network.go │ │ │ │ ├── optional_bool.go │ │ │ │ ├── optional_bool_test.go │ │ │ │ ├── output.go │ │ │ │ ├── resource_pool.go │ │ │ │ ├── search.go │ │ │ │ ├── storage_pod.go │ │ │ │ ├── version.go │ │ │ │ ├── version_test.go │ │ │ │ ├── virtual_app.go │ │ │ │ └── virtual_machine.go │ │ │ ├── folder/ │ │ │ │ ├── create.go │ │ │ │ └── info.go │ │ │ ├── host/ │ │ │ │ ├── account/ │ │ │ │ │ ├── account.go │ │ │ │ │ ├── create.go │ │ │ │ │ ├── remove.go │ │ │ │ │ └── update.go │ │ │ │ ├── add.go │ │ │ │ ├── autostart/ │ │ │ │ │ ├── add.go │ │ │ │ │ ├── autostart.go │ │ │ │ │ ├── configure.go │ │ │ │ │ ├── info.go │ │ │ │ │ └── remove.go │ │ │ │ ├── cert/ │ │ │ │ │ ├── csr.go │ │ │ │ │ ├── info.go │ │ │ │ │ └── install.go │ │ │ │ ├── date/ │ │ │ │ │ ├── change.go │ │ │ │ │ └── info.go │ │ │ │ ├── disconnect.go │ │ │ │ ├── esxcli/ │ │ │ │ │ ├── command.go │ │ │ │ │ ├── command_test.go │ │ │ │ │ ├── esxcli.go │ │ │ │ │ ├── executor.go │ │ │ │ │ ├── firewall_info.go │ │ │ │ │ ├── fixtures/ │ │ │ │ │ │ ├── network_vm_list.xml │ │ │ │ │ │ ├── network_vm_port_list.xml │ │ │ │ │ │ └── system_hostname_get.xml │ │ │ │ │ ├── guest_info.go │ │ │ │ │ ├── response.go │ │ │ │ │ └── response_test.go │ │ │ │ ├── firewall/ │ │ │ │ │ └── find.go │ │ │ │ ├── info.go │ │ │ │ ├── maintenance/ │ │ │ │ │ ├── enter.go │ │ │ │ │ └── exit.go │ │ │ │ ├── option/ │ │ │ │ │ ├── ls.go │ │ │ │ │ └── set.go │ │ │ │ ├── portgroup/ │ │ │ │ │ ├── add.go │ │ │ │ │ ├── change.go │ │ │ │ │ ├── info.go │ │ │ │ │ └── remove.go │ │ │ │ ├── reconnect.go │ │ │ │ ├── remove.go │ │ │ │ ├── service/ │ │ │ │ │ ├── command.go │ │ │ │ │ └── ls.go │ │ │ │ ├── shutdown.go │ │ │ │ ├── storage/ │ │ │ │ │ ├── info.go │ │ │ │ │ ├── mark.go │ │ │ │ │ └── partition.go │ │ │ │ ├── vnic/ │ │ │ │ │ ├── info.go │ │ │ │ │ └── service.go │ │ │ │ └── vswitch/ │ │ │ │ ├── add.go │ │ │ │ ├── info.go │ │ │ │ └── remove.go │ │ │ ├── importx/ │ │ │ │ ├── archive.go │ │ │ │ ├── folder.go │ │ │ │ ├── importable.go │ │ │ │ ├── lease_updater.go │ │ │ │ ├── options.go │ │ │ │ ├── ova.go │ │ │ │ ├── ovf.go │ │ │ │ ├── spec.go │ │ │ │ └── vmdk.go │ │ │ ├── license/ │ │ │ │ ├── add.go │ │ │ │ ├── assign.go │ │ │ │ ├── assigned.go │ │ │ │ ├── decode.go │ │ │ │ ├── ls.go │ │ │ │ ├── output.go │ │ │ │ └── remove.go │ │ │ ├── logs/ │ │ │ │ ├── command.go │ │ │ │ ├── download.go │ │ │ │ └── ls.go │ │ │ ├── ls/ │ │ │ │ └── command.go │ │ │ ├── main.go │ │ │ ├── main_test.go │ │ │ ├── metric/ │ │ │ │ ├── change.go │ │ │ │ ├── info.go │ │ │ │ ├── interval/ │ │ │ │ │ ├── change.go │ │ │ │ │ └── info.go │ │ │ │ ├── ls.go │ │ │ │ ├── performance.go │ │ │ │ ├── reset.go │ │ │ │ └── sample.go │ │ │ ├── object/ │ │ │ │ ├── collect.go │ │ │ │ ├── destroy.go │ │ │ │ ├── find.go │ │ │ │ ├── method.go │ │ │ │ ├── mv.go │ │ │ │ ├── reload.go │ │ │ │ └── rename.go │ │ │ ├── option/ │ │ │ │ ├── ls.go │ │ │ │ └── set.go │ │ │ ├── permissions/ │ │ │ │ ├── ls.go │ │ │ │ ├── permissions.go │ │ │ │ ├── remove.go │ │ │ │ └── set.go │ │ │ ├── pool/ │ │ │ │ ├── change.go │ │ │ │ ├── create.go │ │ │ │ ├── destroy.go │ │ │ │ ├── help.go │ │ │ │ ├── info.go │ │ │ │ └── resource_config_spec.go │ │ │ ├── release.sh │ │ │ ├── role/ │ │ │ │ ├── create.go │ │ │ │ ├── ls.go │ │ │ │ ├── remove.go │ │ │ │ ├── update.go │ │ │ │ └── usage.go │ │ │ ├── session/ │ │ │ │ ├── ls.go │ │ │ │ └── rm.go │ │ │ ├── test/ │ │ │ │ ├── .gitignore │ │ │ │ ├── README.md │ │ │ │ ├── boot_order_test.sh │ │ │ │ ├── clean.sh │ │ │ │ ├── cli.bats │ │ │ │ ├── datacenter.bats │ │ │ │ ├── datastore.bats │ │ │ │ ├── datastore_file_manager_test.sh │ │ │ │ ├── datastore_tail_test.sh │ │ │ │ ├── device.bats │ │ │ │ ├── esxbox/ │ │ │ │ │ └── Vagrantfile │ │ │ │ ├── esxcli.bats │ │ │ │ ├── events.bats │ │ │ │ ├── extension.bats │ │ │ │ ├── fields.bats │ │ │ │ ├── firewall.bats │ │ │ │ ├── folder.bats │ │ │ │ ├── govc-sim │ │ │ │ ├── guest_operations_test.sh │ │ │ │ ├── host.bats │ │ │ │ ├── host_cert_sign.sh │ │ │ │ ├── images/ │ │ │ │ │ ├── .gitignore │ │ │ │ │ └── update.sh │ │ │ │ ├── import.bats │ │ │ │ ├── license.bats │ │ │ │ ├── logs.bats │ │ │ │ ├── ls.bats │ │ │ │ ├── metric.bats │ │ │ │ ├── metric_info_test.sh │ │ │ │ ├── network.bats │ │ │ │ ├── object.bats │ │ │ │ ├── pool.bats │ │ │ │ ├── role.bats │ │ │ │ ├── session.bats │ │ │ │ ├── test_helper.bash │ │ │ │ ├── vcsim/ │ │ │ │ │ ├── Vagrantfile │ │ │ │ │ └── provision.sh │ │ │ │ └── vm.bats │ │ │ ├── usage.sh │ │ │ ├── vapp/ │ │ │ │ ├── destroy.go │ │ │ │ └── power.go │ │ │ ├── version/ │ │ │ │ └── command.go │ │ │ └── vm/ │ │ │ ├── change.go │ │ │ ├── clone.go │ │ │ ├── create.go │ │ │ ├── destroy.go │ │ │ ├── disk/ │ │ │ │ ├── attach.go │ │ │ │ ├── change.go │ │ │ │ └── create.go │ │ │ ├── guest/ │ │ │ │ ├── auth.go │ │ │ │ ├── chmod.go │ │ │ │ ├── chown.go │ │ │ │ ├── download.go │ │ │ │ ├── file_attr.go │ │ │ │ ├── getenv.go │ │ │ │ ├── guest.go │ │ │ │ ├── kill.go │ │ │ │ ├── ls.go │ │ │ │ ├── mkdir.go │ │ │ │ ├── mktemp.go │ │ │ │ ├── mv.go │ │ │ │ ├── ps.go │ │ │ │ ├── rm.go │ │ │ │ ├── rmdir.go │ │ │ │ ├── start.go │ │ │ │ ├── tools.go │ │ │ │ ├── touch.go │ │ │ │ └── upload.go │ │ │ ├── info.go │ │ │ ├── ip.go │ │ │ ├── markastemplate.go │ │ │ ├── markasvm.go │ │ │ ├── migrate.go │ │ │ ├── network/ │ │ │ │ ├── add.go │ │ │ │ └── change.go │ │ │ ├── power.go │ │ │ ├── question.go │ │ │ ├── rdm/ │ │ │ │ ├── attach.go │ │ │ │ └── ls.go │ │ │ ├── register.go │ │ │ ├── snapshot/ │ │ │ │ ├── create.go │ │ │ │ ├── remove.go │ │ │ │ ├── revert.go │ │ │ │ └── tree.go │ │ │ ├── unregister.go │ │ │ └── vnc.go │ │ ├── guest/ │ │ │ ├── auth_manager.go │ │ │ ├── file_manager.go │ │ │ ├── operations_manager.go │ │ │ └── process_manager.go │ │ ├── license/ │ │ │ ├── assignment_manager.go │ │ │ └── manager.go │ │ ├── list/ │ │ │ ├── lister.go │ │ │ ├── path.go │ │ │ └── path_test.go │ │ ├── object/ │ │ │ ├── authorization_manager.go │ │ │ ├── authorization_manager_internal.go │ │ │ ├── cluster_compute_resource.go │ │ │ ├── cluster_compute_resource_test.go │ │ │ ├── common.go │ │ │ ├── common_test.go │ │ │ ├── compute_resource.go │ │ │ ├── compute_resource_test.go │ │ │ ├── custom_fields_manager.go │ │ │ ├── customization_spec_manager.go │ │ │ ├── datacenter.go │ │ │ ├── datacenter_test.go │ │ │ ├── datastore.go │ │ │ ├── datastore_file.go │ │ │ ├── datastore_file_manager.go │ │ │ ├── datastore_path.go │ │ │ ├── datastore_path_test.go │ │ │ ├── datastore_test.go │ │ │ ├── diagnostic_log.go │ │ │ ├── diagnostic_manager.go │ │ │ ├── distributed_virtual_portgroup.go │ │ │ ├── distributed_virtual_portgroup_test.go │ │ │ ├── distributed_virtual_switch.go │ │ │ ├── extension_manager.go │ │ │ ├── file_manager.go │ │ │ ├── folder.go │ │ │ ├── folder_test.go │ │ │ ├── history_collector.go │ │ │ ├── host_account_manager.go │ │ │ ├── host_certificate_info.go │ │ │ ├── host_certificate_info_test.go │ │ │ ├── host_certificate_manager.go │ │ │ ├── host_config_manager.go │ │ │ ├── host_datastore_browser.go │ │ │ ├── host_datastore_system.go │ │ │ ├── host_date_time_system.go │ │ │ ├── host_firewall_system.go │ │ │ ├── host_network_system.go │ │ │ ├── host_service_system.go │ │ │ ├── host_storage_system.go │ │ │ ├── host_system.go │ │ │ ├── host_virtual_nic_manager.go │ │ │ ├── host_vsan_internal_system.go │ │ │ ├── host_vsan_system.go │ │ │ ├── http_nfc_lease.go │ │ │ ├── namespace_manager.go │ │ │ ├── network.go │ │ │ ├── network_reference.go │ │ │ ├── network_test.go │ │ │ ├── opaque_network.go │ │ │ ├── option_manager.go │ │ │ ├── ovf_manager.go │ │ │ ├── resource_pool.go │ │ │ ├── search_index.go │ │ │ ├── search_index_test.go │ │ │ ├── storage_pod.go │ │ │ ├── storage_resource_manager.go │ │ │ ├── task.go │ │ │ ├── types.go │ │ │ ├── virtual_app.go │ │ │ ├── virtual_device_list.go │ │ │ ├── virtual_device_list_test.go │ │ │ ├── virtual_disk_manager.go │ │ │ ├── virtual_disk_manager_internal.go │ │ │ ├── virtual_machine.go │ │ │ ├── virtual_machine_test.go │ │ │ └── vmware_distributed_virtual_switch.go │ │ ├── ovf/ │ │ │ ├── cim.go │ │ │ ├── doc.go │ │ │ ├── env.go │ │ │ ├── env_test.go │ │ │ ├── envelope.go │ │ │ ├── ovf.go │ │ │ └── ovf_test.go │ │ ├── pbm/ │ │ │ ├── client.go │ │ │ ├── client_test.go │ │ │ ├── methods/ │ │ │ │ └── methods.go │ │ │ ├── pbm_util.go │ │ │ └── types/ │ │ │ ├── enum.go │ │ │ ├── if.go │ │ │ └── types.go │ │ ├── performance/ │ │ │ └── manager.go │ │ ├── property/ │ │ │ ├── collector.go │ │ │ ├── filter.go │ │ │ ├── filter_test.go │ │ │ └── wait.go │ │ ├── scripts/ │ │ │ ├── .gitignore │ │ │ ├── contributors.sh │ │ │ ├── debug-ls.sh │ │ │ ├── debug-xmlformat.sh │ │ │ ├── govc-env.bash │ │ │ ├── govc_bash_completion │ │ │ ├── headers/ │ │ │ │ ├── go.txt │ │ │ │ └── rb.txt │ │ │ ├── license.sh │ │ │ ├── vagrant/ │ │ │ │ └── vcsa/ │ │ │ │ ├── .gitignore │ │ │ │ ├── Vagrantfile │ │ │ │ ├── create-box.sh │ │ │ │ └── vagrant.sh │ │ │ ├── wireshark-esx.sh │ │ │ └── wireshark-vcsa.sh │ │ ├── session/ │ │ │ ├── keep_alive.go │ │ │ ├── keep_alive_test.go │ │ │ ├── manager.go │ │ │ └── manager_test.go │ │ ├── task/ │ │ │ ├── error.go │ │ │ ├── wait.go │ │ │ └── wait_test.go │ │ ├── test/ │ │ │ ├── doc.go │ │ │ ├── functional/ │ │ │ │ ├── helper.go │ │ │ │ └── issue_242_test.go │ │ │ └── helper.go │ │ ├── units/ │ │ │ ├── size.go │ │ │ └── size_test.go │ │ ├── view/ │ │ │ ├── container_view.go │ │ │ ├── list_view.go │ │ │ └── manager.go │ │ └── vim25/ │ │ ├── client.go │ │ ├── client_test.go │ │ ├── debug/ │ │ │ └── debug.go │ │ ├── doc.go │ │ ├── methods/ │ │ │ ├── fault_test.go │ │ │ ├── internal.go │ │ │ ├── methods.go │ │ │ └── service_content.go │ │ ├── mo/ │ │ │ ├── ancestors.go │ │ │ ├── entity.go │ │ │ ├── extra.go │ │ │ ├── fixtures/ │ │ │ │ ├── cluster_host_property.xml │ │ │ │ ├── hostsystem_list_name_property.xml │ │ │ │ ├── nested_property.xml │ │ │ │ ├── not_authenticated_fault.xml │ │ │ │ └── pointer_property.xml │ │ │ ├── mo.go │ │ │ ├── reference.go │ │ │ ├── registry.go │ │ │ ├── retrieve.go │ │ │ ├── retrieve_test.go │ │ │ ├── type_info.go │ │ │ └── type_info_test.go │ │ ├── progress/ │ │ │ ├── aggregator.go │ │ │ ├── aggregator_test.go │ │ │ ├── common_test.go │ │ │ ├── doc.go │ │ │ ├── prefix.go │ │ │ ├── prefix_test.go │ │ │ ├── reader.go │ │ │ ├── reader_test.go │ │ │ ├── report.go │ │ │ ├── scale.go │ │ │ ├── scale_test.go │ │ │ ├── sinker.go │ │ │ ├── tee.go │ │ │ └── tee_test.go │ │ ├── retry.go │ │ ├── retry_test.go │ │ ├── soap/ │ │ │ ├── client.go │ │ │ ├── client_test.go │ │ │ ├── debug.go │ │ │ ├── error.go │ │ │ ├── soap.go │ │ │ └── soap_test.go │ │ ├── types/ │ │ │ ├── base.go │ │ │ ├── base_test.go │ │ │ ├── enum.go │ │ │ ├── fault.go │ │ │ ├── helpers.go │ │ │ ├── if.go │ │ │ ├── internal.go │ │ │ ├── registry.go │ │ │ ├── registry_test.go │ │ │ ├── types.go │ │ │ └── types_test.go │ │ └── xml/ │ │ ├── LICENSE │ │ ├── atom_test.go │ │ ├── example_test.go │ │ ├── extras.go │ │ ├── extras_test.go │ │ ├── marshal.go │ │ ├── marshal_test.go │ │ ├── read.go │ │ ├── read_test.go │ │ ├── typeinfo.go │ │ ├── xml.go │ │ └── xml_test.go │ └── golang.org/ │ └── x/ │ └── net/ │ ├── .gitattributes │ ├── .gitignore │ ├── AUTHORS │ ├── CONTRIBUTING.md │ ├── CONTRIBUTORS │ ├── LICENSE │ ├── PATENTS │ ├── README.md │ ├── bpf/ │ │ ├── asm.go │ │ ├── constants.go │ │ ├── doc.go │ │ ├── instructions.go │ │ ├── instructions_test.go │ │ ├── setter.go │ │ ├── testdata/ │ │ │ ├── all_instructions.bpf │ │ │ └── all_instructions.txt │ │ ├── vm.go │ │ ├── vm_aluop_test.go │ │ ├── vm_bpf_test.go │ │ ├── vm_extension_test.go │ │ ├── vm_instructions.go │ │ ├── vm_jump_test.go │ │ ├── vm_load_test.go │ │ ├── vm_ret_test.go │ │ ├── vm_scratch_test.go │ │ └── vm_test.go │ ├── codereview.cfg │ ├── context/ │ │ ├── context.go │ │ ├── context_test.go │ │ ├── ctxhttp/ │ │ │ ├── ctxhttp.go │ │ │ ├── ctxhttp_17_test.go │ │ │ ├── ctxhttp_pre17.go │ │ │ ├── ctxhttp_pre17_test.go │ │ │ └── ctxhttp_test.go │ │ ├── go17.go │ │ ├── go19.go │ │ ├── pre_go17.go │ │ ├── pre_go19.go │ │ └── withtimeout_test.go │ ├── dict/ │ │ └── dict.go │ ├── dns/ │ │ └── dnsmessage/ │ │ ├── example_test.go │ │ ├── message.go │ │ └── message_test.go │ ├── html/ │ │ ├── atom/ │ │ │ ├── atom.go │ │ │ ├── atom_test.go │ │ │ ├── gen.go │ │ │ ├── table.go │ │ │ └── table_test.go │ │ ├── charset/ │ │ │ ├── charset.go │ │ │ ├── charset_test.go │ │ │ └── testdata/ │ │ │ ├── HTTP-charset.html │ │ │ ├── HTTP-vs-UTF-8-BOM.html │ │ │ ├── HTTP-vs-meta-charset.html │ │ │ ├── HTTP-vs-meta-content.html │ │ │ ├── No-encoding-declaration.html │ │ │ ├── README │ │ │ ├── UTF-16BE-BOM.html │ │ │ ├── UTF-16LE-BOM.html │ │ │ ├── UTF-8-BOM-vs-meta-charset.html │ │ │ ├── UTF-8-BOM-vs-meta-content.html │ │ │ ├── meta-charset-attribute.html │ │ │ └── meta-content-attribute.html │ │ ├── const.go │ │ ├── doc.go │ │ ├── doctype.go │ │ ├── entity.go │ │ ├── entity_test.go │ │ ├── escape.go │ │ ├── escape_test.go │ │ ├── example_test.go │ │ ├── foreign.go │ │ ├── node.go │ │ ├── node_test.go │ │ ├── parse.go │ │ ├── parse_test.go │ │ ├── render.go │ │ ├── render_test.go │ │ ├── testdata/ │ │ │ ├── go1.html │ │ │ └── webkit/ │ │ │ └── README │ │ ├── token.go │ │ └── token_test.go │ ├── http2/ │ │ ├── .gitignore │ │ ├── Dockerfile │ │ ├── Makefile │ │ ├── README │ │ ├── ciphers.go │ │ ├── ciphers_test.go │ │ ├── client_conn_pool.go │ │ ├── configure_transport.go │ │ ├── databuffer.go │ │ ├── databuffer_test.go │ │ ├── errors.go │ │ ├── errors_test.go │ │ ├── flow.go │ │ ├── flow_test.go │ │ ├── frame.go │ │ ├── frame_test.go │ │ ├── go16.go │ │ ├── go17.go │ │ ├── go17_not18.go │ │ ├── go18.go │ │ ├── go18_test.go │ │ ├── go19.go │ │ ├── go19_test.go │ │ ├── gotrack.go │ │ ├── gotrack_test.go │ │ ├── h2i/ │ │ │ ├── README.md │ │ │ └── h2i.go │ │ ├── headermap.go │ │ ├── hpack/ │ │ │ ├── encode.go │ │ │ ├── encode_test.go │ │ │ ├── hpack.go │ │ │ ├── hpack_test.go │ │ │ ├── huffman.go │ │ │ ├── tables.go │ │ │ └── tables_test.go │ │ ├── http2.go │ │ ├── http2_test.go │ │ ├── not_go16.go │ │ ├── not_go17.go │ │ ├── not_go18.go │ │ ├── not_go19.go │ │ ├── pipe.go │ │ ├── pipe_test.go │ │ ├── server.go │ │ ├── server_push_test.go │ │ ├── server_test.go │ │ ├── testdata/ │ │ │ └── draft-ietf-httpbis-http2.xml │ │ ├── transport.go │ │ ├── transport_test.go │ │ ├── write.go │ │ ├── writesched.go │ │ ├── writesched_priority.go │ │ ├── writesched_priority_test.go │ │ ├── writesched_random.go │ │ ├── writesched_random_test.go │ │ ├── writesched_test.go │ │ └── z_spec_test.go │ ├── icmp/ │ │ ├── dstunreach.go │ │ ├── echo.go │ │ ├── endpoint.go │ │ ├── example_test.go │ │ ├── extension.go │ │ ├── extension_test.go │ │ ├── helper_posix.go │ │ ├── interface.go │ │ ├── ipv4.go │ │ ├── ipv4_test.go │ │ ├── ipv6.go │ │ ├── listen_posix.go │ │ ├── listen_stub.go │ │ ├── message.go │ │ ├── message_test.go │ │ ├── messagebody.go │ │ ├── mpls.go │ │ ├── multipart.go │ │ ├── multipart_test.go │ │ ├── packettoobig.go │ │ ├── paramprob.go │ │ ├── ping_test.go │ │ ├── sys_freebsd.go │ │ └── timeexceeded.go │ ├── idna/ │ │ ├── example_test.go │ │ ├── idna.go │ │ ├── idna_test.go │ │ ├── punycode.go │ │ ├── punycode_test.go │ │ ├── tables.go │ │ ├── trie.go │ │ └── trieval.go │ ├── internal/ │ │ ├── iana/ │ │ │ ├── const.go │ │ │ └── gen.go │ │ ├── nettest/ │ │ │ ├── helper_bsd.go │ │ │ ├── helper_nobsd.go │ │ │ ├── helper_posix.go │ │ │ ├── helper_stub.go │ │ │ ├── helper_unix.go │ │ │ ├── helper_windows.go │ │ │ ├── interface.go │ │ │ ├── rlimit.go │ │ │ └── stack.go │ │ ├── socket/ │ │ │ ├── cmsghdr.go │ │ │ ├── cmsghdr_bsd.go │ │ │ ├── cmsghdr_linux_32bit.go │ │ │ ├── cmsghdr_linux_64bit.go │ │ │ ├── cmsghdr_solaris_64bit.go │ │ │ ├── cmsghdr_stub.go │ │ │ ├── defs_darwin.go │ │ │ ├── defs_dragonfly.go │ │ │ ├── defs_freebsd.go │ │ │ ├── defs_linux.go │ │ │ ├── defs_netbsd.go │ │ │ ├── defs_openbsd.go │ │ │ ├── defs_solaris.go │ │ │ ├── error_unix.go │ │ │ ├── error_windows.go │ │ │ ├── iovec_32bit.go │ │ │ ├── iovec_64bit.go │ │ │ ├── iovec_solaris_64bit.go │ │ │ ├── iovec_stub.go │ │ │ ├── mmsghdr_stub.go │ │ │ ├── mmsghdr_unix.go │ │ │ ├── msghdr_bsd.go │ │ │ ├── msghdr_bsdvar.go │ │ │ ├── msghdr_linux.go │ │ │ ├── msghdr_linux_32bit.go │ │ │ ├── msghdr_linux_64bit.go │ │ │ ├── msghdr_openbsd.go │ │ │ ├── msghdr_solaris_64bit.go │ │ │ ├── msghdr_stub.go │ │ │ ├── rawconn.go │ │ │ ├── rawconn_mmsg.go │ │ │ ├── rawconn_msg.go │ │ │ ├── rawconn_nommsg.go │ │ │ ├── rawconn_nomsg.go │ │ │ ├── rawconn_stub.go │ │ │ ├── reflect.go │ │ │ ├── socket.go │ │ │ ├── socket_go1_9_test.go │ │ │ ├── socket_test.go │ │ │ ├── sys.go │ │ │ ├── sys_bsd.go │ │ │ ├── sys_bsdvar.go │ │ │ ├── sys_darwin.go │ │ │ ├── sys_dragonfly.go │ │ │ ├── sys_linux.go │ │ │ ├── sys_linux_386.go │ │ │ ├── sys_linux_386.s │ │ │ ├── sys_linux_amd64.go │ │ │ ├── sys_linux_arm.go │ │ │ ├── sys_linux_arm64.go │ │ │ ├── sys_linux_mips.go │ │ │ ├── sys_linux_mips64.go │ │ │ ├── sys_linux_mips64le.go │ │ │ ├── sys_linux_mipsle.go │ │ │ ├── sys_linux_ppc64.go │ │ │ ├── sys_linux_ppc64le.go │ │ │ ├── sys_linux_s390x.go │ │ │ ├── sys_linux_s390x.s │ │ │ ├── sys_netbsd.go │ │ │ ├── sys_posix.go │ │ │ ├── sys_solaris.go │ │ │ ├── sys_solaris_amd64.s │ │ │ ├── sys_stub.go │ │ │ ├── sys_unix.go │ │ │ ├── sys_windows.go │ │ │ ├── zsys_darwin_386.go │ │ │ ├── zsys_darwin_amd64.go │ │ │ ├── zsys_darwin_arm.go │ │ │ ├── zsys_dragonfly_amd64.go │ │ │ ├── zsys_freebsd_386.go │ │ │ ├── zsys_freebsd_amd64.go │ │ │ ├── zsys_freebsd_arm.go │ │ │ ├── zsys_linux_386.go │ │ │ ├── zsys_linux_amd64.go │ │ │ ├── zsys_linux_arm.go │ │ │ ├── zsys_linux_arm64.go │ │ │ ├── zsys_linux_mips.go │ │ │ ├── zsys_linux_mips64.go │ │ │ ├── zsys_linux_mips64le.go │ │ │ ├── zsys_linux_mipsle.go │ │ │ ├── zsys_linux_ppc64.go │ │ │ ├── zsys_linux_ppc64le.go │ │ │ ├── zsys_linux_s390x.go │ │ │ ├── zsys_netbsd_386.go │ │ │ ├── zsys_netbsd_amd64.go │ │ │ ├── zsys_netbsd_arm.go │ │ │ ├── zsys_openbsd_386.go │ │ │ ├── zsys_openbsd_amd64.go │ │ │ ├── zsys_openbsd_arm.go │ │ │ └── zsys_solaris_amd64.go │ │ └── timeseries/ │ │ ├── timeseries.go │ │ └── timeseries_test.go │ ├── ipv4/ │ │ ├── batch.go │ │ ├── bpf_test.go │ │ ├── control.go │ │ ├── control_bsd.go │ │ ├── control_pktinfo.go │ │ ├── control_stub.go │ │ ├── control_test.go │ │ ├── control_unix.go │ │ ├── control_windows.go │ │ ├── defs_darwin.go │ │ ├── defs_dragonfly.go │ │ ├── defs_freebsd.go │ │ ├── defs_linux.go │ │ ├── defs_netbsd.go │ │ ├── defs_openbsd.go │ │ ├── defs_solaris.go │ │ ├── dgramopt.go │ │ ├── doc.go │ │ ├── endpoint.go │ │ ├── example_test.go │ │ ├── gen.go │ │ ├── genericopt.go │ │ ├── header.go │ │ ├── header_test.go │ │ ├── helper.go │ │ ├── iana.go │ │ ├── icmp.go │ │ ├── icmp_linux.go │ │ ├── icmp_stub.go │ │ ├── icmp_test.go │ │ ├── multicast_test.go │ │ ├── multicastlistener_test.go │ │ ├── multicastsockopt_test.go │ │ ├── packet.go │ │ ├── packet_go1_8.go │ │ ├── packet_go1_9.go │ │ ├── payload.go │ │ ├── payload_cmsg.go │ │ ├── payload_cmsg_go1_8.go │ │ ├── payload_cmsg_go1_9.go │ │ ├── payload_nocmsg.go │ │ ├── readwrite_go1_8_test.go │ │ ├── readwrite_go1_9_test.go │ │ ├── readwrite_test.go │ │ ├── sockopt.go │ │ ├── sockopt_posix.go │ │ ├── sockopt_stub.go │ │ ├── sys_asmreq.go │ │ ├── sys_asmreq_stub.go │ │ ├── sys_asmreqn.go │ │ ├── sys_asmreqn_stub.go │ │ ├── sys_bpf.go │ │ ├── sys_bpf_stub.go │ │ ├── sys_bsd.go │ │ ├── sys_darwin.go │ │ ├── sys_dragonfly.go │ │ ├── sys_freebsd.go │ │ ├── sys_linux.go │ │ ├── sys_solaris.go │ │ ├── sys_ssmreq.go │ │ ├── sys_ssmreq_stub.go │ │ ├── sys_stub.go │ │ ├── sys_windows.go │ │ ├── unicast_test.go │ │ ├── unicastsockopt_test.go │ │ ├── zsys_darwin.go │ │ ├── zsys_dragonfly.go │ │ ├── zsys_freebsd_386.go │ │ ├── zsys_freebsd_amd64.go │ │ ├── zsys_freebsd_arm.go │ │ ├── zsys_linux_386.go │ │ ├── zsys_linux_amd64.go │ │ ├── zsys_linux_arm.go │ │ ├── zsys_linux_arm64.go │ │ ├── zsys_linux_mips.go │ │ ├── zsys_linux_mips64.go │ │ ├── zsys_linux_mips64le.go │ │ ├── zsys_linux_mipsle.go │ │ ├── zsys_linux_ppc.go │ │ ├── zsys_linux_ppc64.go │ │ ├── zsys_linux_ppc64le.go │ │ ├── zsys_linux_s390x.go │ │ ├── zsys_netbsd.go │ │ ├── zsys_openbsd.go │ │ └── zsys_solaris.go │ ├── ipv6/ │ │ ├── batch.go │ │ ├── bpf_test.go │ │ ├── control.go │ │ ├── control_rfc2292_unix.go │ │ ├── control_rfc3542_unix.go │ │ ├── control_stub.go │ │ ├── control_test.go │ │ ├── control_unix.go │ │ ├── control_windows.go │ │ ├── defs_darwin.go │ │ ├── defs_dragonfly.go │ │ ├── defs_freebsd.go │ │ ├── defs_linux.go │ │ ├── defs_netbsd.go │ │ ├── defs_openbsd.go │ │ ├── defs_solaris.go │ │ ├── dgramopt.go │ │ ├── doc.go │ │ ├── endpoint.go │ │ ├── example_test.go │ │ ├── gen.go │ │ ├── genericopt.go │ │ ├── header.go │ │ ├── header_test.go │ │ ├── helper.go │ │ ├── iana.go │ │ ├── icmp.go │ │ ├── icmp_bsd.go │ │ ├── icmp_linux.go │ │ ├── icmp_solaris.go │ │ ├── icmp_stub.go │ │ ├── icmp_test.go │ │ ├── icmp_windows.go │ │ ├── mocktransponder_test.go │ │ ├── multicast_test.go │ │ ├── multicastlistener_test.go │ │ ├── multicastsockopt_test.go │ │ ├── payload.go │ │ ├── payload_cmsg.go │ │ ├── payload_cmsg_go1_8.go │ │ ├── payload_cmsg_go1_9.go │ │ ├── payload_nocmsg.go │ │ ├── readwrite_go1_8_test.go │ │ ├── readwrite_go1_9_test.go │ │ ├── readwrite_test.go │ │ ├── sockopt.go │ │ ├── sockopt_posix.go │ │ ├── sockopt_stub.go │ │ ├── sockopt_test.go │ │ ├── sys_asmreq.go │ │ ├── sys_asmreq_stub.go │ │ ├── sys_bpf.go │ │ ├── sys_bpf_stub.go │ │ ├── sys_bsd.go │ │ ├── sys_darwin.go │ │ ├── sys_freebsd.go │ │ ├── sys_linux.go │ │ ├── sys_solaris.go │ │ ├── sys_ssmreq.go │ │ ├── sys_ssmreq_stub.go │ │ ├── sys_stub.go │ │ ├── sys_windows.go │ │ ├── unicast_test.go │ │ ├── unicastsockopt_test.go │ │ ├── zsys_darwin.go │ │ ├── zsys_dragonfly.go │ │ ├── zsys_freebsd_386.go │ │ ├── zsys_freebsd_amd64.go │ │ ├── zsys_freebsd_arm.go │ │ ├── zsys_linux_386.go │ │ ├── zsys_linux_amd64.go │ │ ├── zsys_linux_arm.go │ │ ├── zsys_linux_arm64.go │ │ ├── zsys_linux_mips.go │ │ ├── zsys_linux_mips64.go │ │ ├── zsys_linux_mips64le.go │ │ ├── zsys_linux_mipsle.go │ │ ├── zsys_linux_ppc.go │ │ ├── zsys_linux_ppc64.go │ │ ├── zsys_linux_ppc64le.go │ │ ├── zsys_linux_s390x.go │ │ ├── zsys_netbsd.go │ │ ├── zsys_openbsd.go │ │ └── zsys_solaris.go │ ├── lex/ │ │ └── httplex/ │ │ ├── httplex.go │ │ └── httplex_test.go │ ├── lif/ │ │ ├── address.go │ │ ├── address_test.go │ │ ├── binary.go │ │ ├── defs_solaris.go │ │ ├── lif.go │ │ ├── link.go │ │ ├── link_test.go │ │ ├── sys.go │ │ ├── sys_solaris_amd64.s │ │ ├── syscall.go │ │ └── zsys_solaris_amd64.go │ ├── nettest/ │ │ ├── conntest.go │ │ ├── conntest_go16.go │ │ ├── conntest_go17.go │ │ └── conntest_test.go │ ├── netutil/ │ │ ├── listen.go │ │ └── listen_test.go │ ├── proxy/ │ │ ├── direct.go │ │ ├── per_host.go │ │ ├── per_host_test.go │ │ ├── proxy.go │ │ ├── proxy_test.go │ │ └── socks5.go │ ├── publicsuffix/ │ │ ├── gen.go │ │ ├── list.go │ │ ├── list_test.go │ │ ├── table.go │ │ └── table_test.go │ ├── route/ │ │ ├── address.go │ │ ├── address_darwin_test.go │ │ ├── address_test.go │ │ ├── binary.go │ │ ├── defs_darwin.go │ │ ├── defs_dragonfly.go │ │ ├── defs_freebsd.go │ │ ├── defs_netbsd.go │ │ ├── defs_openbsd.go │ │ ├── interface.go │ │ ├── interface_announce.go │ │ ├── interface_classic.go │ │ ├── interface_freebsd.go │ │ ├── interface_multicast.go │ │ ├── interface_openbsd.go │ │ ├── message.go │ │ ├── message_darwin_test.go │ │ ├── message_freebsd_test.go │ │ ├── message_test.go │ │ ├── route.go │ │ ├── route_classic.go │ │ ├── route_openbsd.go │ │ ├── route_test.go │ │ ├── sys.go │ │ ├── sys_darwin.go │ │ ├── sys_dragonfly.go │ │ ├── sys_freebsd.go │ │ ├── sys_netbsd.go │ │ ├── sys_openbsd.go │ │ ├── syscall.go │ │ ├── zsys_darwin.go │ │ ├── zsys_dragonfly.go │ │ ├── zsys_freebsd_386.go │ │ ├── zsys_freebsd_amd64.go │ │ ├── zsys_freebsd_arm.go │ │ ├── zsys_netbsd.go │ │ └── zsys_openbsd.go │ ├── trace/ │ │ ├── events.go │ │ ├── histogram.go │ │ ├── histogram_test.go │ │ ├── trace.go │ │ ├── trace_go16.go │ │ ├── trace_go17.go │ │ └── trace_test.go │ ├── webdav/ │ │ ├── file.go │ │ ├── file_go1.6.go │ │ ├── file_go1.7.go │ │ ├── file_test.go │ │ ├── if.go │ │ ├── if_test.go │ │ ├── internal/ │ │ │ └── xml/ │ │ │ ├── README │ │ │ ├── atom_test.go │ │ │ ├── example_test.go │ │ │ ├── marshal.go │ │ │ ├── marshal_test.go │ │ │ ├── read.go │ │ │ ├── read_test.go │ │ │ ├── typeinfo.go │ │ │ ├── xml.go │ │ │ └── xml_test.go │ │ ├── litmus_test_server.go │ │ ├── lock.go │ │ ├── lock_test.go │ │ ├── prop.go │ │ ├── prop_test.go │ │ ├── webdav.go │ │ ├── webdav_test.go │ │ ├── xml.go │ │ └── xml_test.go │ ├── websocket/ │ │ ├── client.go │ │ ├── dial.go │ │ ├── dial_test.go │ │ ├── exampledial_test.go │ │ ├── examplehandler_test.go │ │ ├── hybi.go │ │ ├── hybi_test.go │ │ ├── server.go │ │ ├── websocket.go │ │ └── websocket_test.go │ └── xsrftoken/ │ ├── xsrf.go │ └── xsrf_test.go ├── vsphere-influxdb.go └── vsphere-influxdb.json.sample
Showing preview only (3,355K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (40594 symbols across 1281 files)
FILE: tools/change_metric_collection_level.py
function PrintException (line 30) | def PrintException():
function get_args (line 40) | def get_args():
function change_level (line 61) | def change_level(host, user, pwd, port, level, key, name):
FILE: vendor/github.com/davecgh/go-spew/spew/bypass.go
constant UnsafeDisabled (line 31) | UnsafeDisabled = false
constant ptrSize (line 34) | ptrSize = unsafe.Sizeof((*byte)(nil))
function init (line 66) | func init() {
function unsafeReflectValue (line 122) | func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
FILE: vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
constant UnsafeDisabled (line 28) | UnsafeDisabled = true
function unsafeReflectValue (line 36) | func unsafeReflectValue(v reflect.Value) reflect.Value {
FILE: vendor/github.com/davecgh/go-spew/spew/common.go
function catchPanic (line 72) | func catchPanic(w io.Writer, v reflect.Value) {
function handleMethods (line 85) | func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handl...
function printBool (line 144) | func printBool(w io.Writer, val bool) {
function printInt (line 153) | func printInt(w io.Writer, val int64, base int) {
function printUint (line 158) | func printUint(w io.Writer, val uint64, base int) {
function printFloat (line 164) | func printFloat(w io.Writer, val float64, precision int) {
function printComplex (line 170) | func printComplex(w io.Writer, c complex128, floatPrecision int) {
function printHexPtr (line 185) | func printHexPtr(w io.Writer, p uintptr) {
type valuesSorter (line 219) | type valuesSorter struct
method Len (line 279) | func (s *valuesSorter) Len() int {
method Swap (line 285) | func (s *valuesSorter) Swap(i, j int) {
method Less (line 326) | func (s *valuesSorter) Less(i, j int) bool {
function newValuesSorter (line 228) | func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Inter...
function canSortSimply (line 256) | func canSortSimply(kind reflect.Kind) bool {
function valueSortLess (line 295) | func valueSortLess(a, b reflect.Value) bool {
function sortValues (line 336) | func sortValues(values []reflect.Value, cs *ConfigState) {
FILE: vendor/github.com/davecgh/go-spew/spew/common_test.go
type stringer (line 28) | type stringer
method String (line 32) | func (s stringer) String() string {
type pstringer (line 37) | type pstringer
method String (line 41) | func (s *pstringer) String() string {
type xref1 (line 47) | type xref1 struct
type xref2 (line 50) | type xref2 struct
type indirCir1 (line 56) | type indirCir1 struct
type indirCir2 (line 59) | type indirCir2 struct
type indirCir3 (line 62) | type indirCir3 struct
type embed (line 67) | type embed struct
type embedwrap (line 72) | type embedwrap struct
type panicer (line 79) | type panicer
method String (line 81) | func (p panicer) String() string {
type customError (line 86) | type customError
method Error (line 88) | func (e customError) Error() string {
function stringizeWants (line 94) | func stringizeWants(wants []string) string {
function testFailed (line 108) | func testFailed(result string, wants []string) bool {
type sortableStruct (line 117) | type sortableStruct struct
method String (line 121) | func (ss sortableStruct) String() string {
type unsortableStruct (line 125) | type unsortableStruct struct
type sortTestCase (line 129) | type sortTestCase struct
function helpTestSortValues (line 134) | func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *t...
function TestSortValues (line 159) | func TestSortValues(t *testing.T) {
function TestSortValuesWithMethods (line 233) | func TestSortValuesWithMethods(t *testing.T) {
function TestSortValuesWithSpew (line 268) | func TestSortValuesWithSpew(t *testing.T) {
FILE: vendor/github.com/davecgh/go-spew/spew/config.go
type ConfigState (line 37) | type ConfigState struct
method Errorf (line 115) | func (c *ConfigState) Errorf(format string, a ...interface{}) (err err...
method Fprint (line 127) | func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, er...
method Fprintf (line 139) | func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interfa...
method Fprintln (line 150) | func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, ...
method Print (line 162) | func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
method Printf (line 174) | func (c *ConfigState) Printf(format string, a ...interface{}) (n int, ...
method Println (line 186) | func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
method Sprint (line 197) | func (c *ConfigState) Sprint(a ...interface{}) string {
method Sprintf (line 208) | func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
method Sprintln (line 219) | func (c *ConfigState) Sprintln(a ...interface{}) string {
method NewFormatter (line 240) | func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
method Fdump (line 246) | func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
method Dump (line 273) | func (c *ConfigState) Dump(a ...interface{}) {
method Sdump (line 279) | func (c *ConfigState) Sdump(a ...interface{}) string {
method convertArgs (line 288) | func (c *ConfigState) convertArgs(args []interface{}) (formatters []in...
function NewDefaultConfig (line 304) | func NewDefaultConfig() *ConfigState {
FILE: vendor/github.com/davecgh/go-spew/spew/dump.go
type dumpState (line 51) | type dumpState struct
method indent (line 62) | func (d *dumpState) indent() {
method unpackValue (line 73) | func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
method dumpPtr (line 81) | func (d *dumpState) dumpPtr(v reflect.Value) {
method dumpSlice (line 161) | func (d *dumpState) dumpSlice(v reflect.Value) {
method dump (line 251) | func (d *dumpState) dump(v reflect.Value) {
function fdump (line 453) | func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
function Fdump (line 472) | func Fdump(w io.Writer, a ...interface{}) {
function Sdump (line 478) | func Sdump(a ...interface{}) string {
function Dump (line 507) | func Dump(a ...interface{}) {
FILE: vendor/github.com/davecgh/go-spew/spew/dump_test.go
type dumpTest (line 74) | type dumpTest struct
function addDumpTest (line 84) | func addDumpTest(in interface{}, wants ...string) {
function addIntDumpTests (line 89) | func addIntDumpTests() {
function addUintDumpTests (line 156) | func addUintDumpTests() {
function addBoolDumpTests (line 223) | func addBoolDumpTests() {
function addFloatDumpTests (line 249) | func addFloatDumpTests() {
function addComplexDumpTests (line 277) | func addComplexDumpTests() {
function addArrayDumpTests (line 305) | func addArrayDumpTests() {
function addSliceDumpTests (line 403) | func addSliceDumpTests() {
function addStringDumpTests (line 508) | func addStringDumpTests() {
function addInterfaceDumpTests (line 524) | func addInterfaceDumpTests() {
function addMapDumpTests (line 550) | func addMapDumpTests() {
function addStructDumpTests (line 651) | func addStructDumpTests() {
function addUintptrDumpTests (line 742) | func addUintptrDumpTests() {
function addUnsafePointerDumpTests (line 769) | func addUnsafePointerDumpTests() {
function addChanDumpTests (line 797) | func addChanDumpTests() {
function addFuncDumpTests (line 823) | func addFuncDumpTests() {
function addCircularDumpTests (line 866) | func addCircularDumpTests() {
function addPanicDumpTests (line 929) | func addPanicDumpTests() {
function addErrorDumpTests (line 944) | func addErrorDumpTests() {
function TestDump (line 960) | func TestDump(t *testing.T) {
function TestDumpSortedKeys (line 994) | func TestDumpSortedKeys(t *testing.T) {
FILE: vendor/github.com/davecgh/go-spew/spew/dumpcgo_test.go
function addCgoDumpTests (line 32) | func addCgoDumpTests() {
FILE: vendor/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
function addCgoDumpTests (line 23) | func addCgoDumpTests() {
FILE: vendor/github.com/davecgh/go-spew/spew/example_test.go
type Flag (line 25) | type Flag
method String (line 37) | func (f Flag) String() string {
constant flagOne (line 28) | flagOne Flag = iota
constant flagTwo (line 29) | flagTwo
type Bar (line 44) | type Bar struct
type Foo (line 48) | type Foo struct
function ExampleDump (line 54) | func ExampleDump() {
function ExamplePrintf (line 121) | func ExamplePrintf() {
function ExampleConfigState (line 145) | func ExampleConfigState() {
function ExampleConfigState_Dump (line 164) | func ExampleConfigState_Dump() {
function ExampleConfigState_Printf (line 202) | func ExampleConfigState_Printf() {
FILE: vendor/github.com/davecgh/go-spew/spew/format.go
constant supportedFlags (line 28) | supportedFlags = "0-+# "
type formatState (line 34) | type formatState struct
method buildDefaultFormat (line 47) | func (f *formatState) buildDefaultFormat() (format string) {
method constructOrigFormat (line 65) | func (f *formatState) constructOrigFormat(verb rune) (format string) {
method unpackValue (line 94) | func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
method formatPtr (line 105) | func (f *formatState) formatPtr(v reflect.Value) {
method format (line 201) | func (f *formatState) format(v reflect.Value) {
method Format (line 371) | func (f *formatState) Format(fs fmt.State, verb rune) {
function newFormatter (line 394) | func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
function NewFormatter (line 417) | func NewFormatter(v interface{}) fmt.Formatter {
FILE: vendor/github.com/davecgh/go-spew/spew/format_test.go
type formatterTest (line 79) | type formatterTest struct
function addFormatterTest (line 90) | func addFormatterTest(format string, in interface{}, wants ...string) {
function addIntFormatterTests (line 95) | func addIntFormatterTests() {
function addUintFormatterTests (line 222) | func addUintFormatterTests() {
function addBoolFormatterTests (line 349) | func addBoolFormatterTests() {
function addFloatFormatterTests (line 396) | func addFloatFormatterTests() {
function addComplexFormatterTests (line 448) | func addComplexFormatterTests() {
function addArrayFormatterTests (line 500) | func addArrayFormatterTests() {
function addSliceFormatterTests (line 585) | func addSliceFormatterTests() {
function addStringFormatterTests (line 693) | func addStringFormatterTests() {
function addInterfaceFormatterTests (line 720) | func addInterfaceFormatterTests() {
function addMapFormatterTests (line 767) | func addMapFormatterTests() {
function addStructFormatterTests (line 886) | func addStructFormatterTests() {
function addUintptrFormatterTests (line 1036) | func addUintptrFormatterTests() {
function addUnsafePointerFormatterTests (line 1084) | func addUnsafePointerFormatterTests() {
function addChanFormatterTests (line 1132) | func addChanFormatterTests() {
function addFuncFormatterTests (line 1179) | func addFuncFormatterTests() {
function addCircularFormatterTests (line 1258) | func addCircularFormatterTests() {
function addPanicFormatterTests (line 1370) | func addPanicFormatterTests() {
function addErrorFormatterTests (line 1397) | func addErrorFormatterTests() {
function addPassthroughFormatterTests (line 1424) | func addPassthroughFormatterTests() {
function TestFormatter (line 1465) | func TestFormatter(t *testing.T) {
type testStruct (line 1500) | type testStruct struct
method String (line 1504) | func (ts testStruct) String() string {
type testStructP (line 1508) | type testStructP struct
method String (line 1512) | func (ts *testStructP) String() string {
function TestPrintSortedKeys (line 1516) | func TestPrintSortedKeys(t *testing.T) {
FILE: vendor/github.com/davecgh/go-spew/spew/internal_test.go
type dummyFmtState (line 34) | type dummyFmtState struct
method Flag (line 38) | func (dfs *dummyFmtState) Flag(f int) bool {
method Precision (line 45) | func (dfs *dummyFmtState) Precision() (int, bool) {
method Width (line 49) | func (dfs *dummyFmtState) Width() (int, bool) {
function TestInvalidReflectValue (line 57) | func TestInvalidReflectValue(t *testing.T) {
function SortValues (line 85) | func SortValues(values []reflect.Value, cs *ConfigState) {
FILE: vendor/github.com/davecgh/go-spew/spew/internalunsafe_test.go
function changeKind (line 40) | func changeKind(v *reflect.Value, readOnly bool) {
function TestAddedReflectValue (line 53) | func TestAddedReflectValue(t *testing.T) {
FILE: vendor/github.com/davecgh/go-spew/spew/spew.go
function Errorf (line 32) | func Errorf(format string, a ...interface{}) (err error) {
function Fprint (line 44) | func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
function Fprintf (line 56) | func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err e...
function Fprintln (line 67) | func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
function Print (line 79) | func Print(a ...interface{}) (n int, err error) {
function Printf (line 91) | func Printf(format string, a ...interface{}) (n int, err error) {
function Println (line 103) | func Println(a ...interface{}) (n int, err error) {
function Sprint (line 114) | func Sprint(a ...interface{}) string {
function Sprintf (line 125) | func Sprintf(format string, a ...interface{}) string {
function Sprintln (line 136) | func Sprintln(a ...interface{}) string {
function convertArgs (line 142) | func convertArgs(args []interface{}) (formatters []interface{}) {
FILE: vendor/github.com/davecgh/go-spew/spew/spew_test.go
type spewFunc (line 31) | type spewFunc
method String (line 82) | func (f spewFunc) String() string {
constant fCSFdump (line 34) | fCSFdump spewFunc = iota
constant fCSFprint (line 35) | fCSFprint
constant fCSFprintf (line 36) | fCSFprintf
constant fCSFprintln (line 37) | fCSFprintln
constant fCSPrint (line 38) | fCSPrint
constant fCSPrintln (line 39) | fCSPrintln
constant fCSSdump (line 40) | fCSSdump
constant fCSSprint (line 41) | fCSSprint
constant fCSSprintf (line 42) | fCSSprintf
constant fCSSprintln (line 43) | fCSSprintln
constant fCSErrorf (line 44) | fCSErrorf
constant fCSNewFormatter (line 45) | fCSNewFormatter
constant fErrorf (line 46) | fErrorf
constant fFprint (line 47) | fFprint
constant fFprintln (line 48) | fFprintln
constant fPrint (line 49) | fPrint
constant fPrintln (line 50) | fPrintln
constant fSdump (line 51) | fSdump
constant fSprint (line 52) | fSprint
constant fSprintf (line 53) | fSprintf
constant fSprintln (line 54) | fSprintln
type spewTest (line 91) | type spewTest struct
function redirStdout (line 109) | func redirStdout(f func()) ([]byte, error) {
function initSpewTests (line 126) | func initSpewTests() {
function TestSpew (line 210) | func TestSpew(t *testing.T) {
FILE: vendor/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go
function GetCgoNullCharPointer (line 44) | func GetCgoNullCharPointer() interface{} {
function GetCgoCharPointer (line 50) | func GetCgoCharPointer() interface{} {
function GetCgoCharArray (line 56) | func GetCgoCharArray() (interface{}, int, int) {
function GetCgoUnsignedCharArray (line 62) | func GetCgoUnsignedCharArray() (interface{}, int, int) {
function GetCgoSignedCharArray (line 68) | func GetCgoSignedCharArray() (interface{}, int, int) {
function GetCgoUint8tArray (line 74) | func GetCgoUint8tArray() (interface{}, int, int) {
function GetCgoTypdefedUnsignedCharArray (line 80) | func GetCgoTypdefedUnsignedCharArray() (interface{}, int, int) {
FILE: vendor/github.com/influxdata/influxdb/build.py
function print_banner (line 106) | def print_banner():
function create_package_fs (line 115) | def create_package_fs(build_root):
function package_scripts (line 132) | def package_scripts(build_root, config_only=False, windows=False):
function package_man_files (line 151) | def package_man_files(build_root):
function go_get (line 159) | def go_get(branch, update=False, no_uncommitted=False):
function run_tests (line 174) | def run_tests(race, parallel, timeout, no_vet, junit=False):
function run (line 239) | def run(command, allow_failure=False, shell=False):
function create_temp_dir (line 268) | def create_temp_dir(prefix = None):
function increment_minor_version (line 276) | def increment_minor_version(version):
function get_current_version_tag (line 290) | def get_current_version_tag():
function get_current_version (line 296) | def get_current_version():
function get_current_commit (line 310) | def get_current_commit(short=False):
function get_current_branch (line 321) | def get_current_branch():
function local_changes (line 328) | def local_changes():
function get_system_arch (line 336) | def get_system_arch():
function get_system_platform (line 351) | def get_system_platform():
function get_go_version (line 359) | def get_go_version():
function check_path_for (line 368) | def check_path_for(b):
function check_environ (line 380) | def check_environ(build_dir = None):
function check_prereqs (line 392) | def check_prereqs():
function upload_packages (line 402) | def upload_packages(packages, bucket_name=None, overwrite=False):
function go_list (line 445) | def go_list(vendor=False, relative=False):
function build (line 471) | def build(version=None,
function generate_md5_from_file (line 569) | def generate_md5_from_file(path):
function generate_sig_from_file (line 578) | def generate_sig_from_file(path):
function package (line 592) | def package(build_output, pkg_name, version, nightly=False, iteration=1,...
function main (line 745) | def main(args):
FILE: vendor/github.com/influxdata/influxdb/client/example_test.go
function ExampleNewClient (line 15) | func ExampleNewClient() {
function ExampleClient_Ping (line 35) | func ExampleClient_Ping() {
function ExampleClient_Query (line 52) | func ExampleClient_Query() {
function ExampleClient_Write (line 71) | func ExampleClient_Write() {
FILE: vendor/github.com/influxdata/influxdb/client/influxdb.go
constant DefaultHost (line 26) | DefaultHost = "localhost"
constant DefaultPort (line 29) | DefaultPort = 8086
constant DefaultTimeout (line 32) | DefaultTimeout = 0
type Query (line 36) | type Query struct
function ParseConnectionString (line 54) | func ParseConnectionString(path string, ssl bool) (url.URL, error) {
type Config (line 92) | type Config struct
function NewConfig (line 105) | func NewConfig() Config {
type Client (line 112) | type Client struct
method SetAuth (line 171) | func (c *Client) SetAuth(u, p string) {
method SetPrecision (line 177) | func (c *Client) SetPrecision(precision string) {
method Query (line 182) | func (c *Client) Query(q Query) (*Response, error) {
method Write (line 257) | func (c *Client) Write(bp BatchPoints) (*Response, error) {
method WriteLineProtocol (line 335) | func (c *Client) WriteLineProtocol(data, database, retentionPolicy, pr...
method Ping (line 380) | func (c *Client) Ping() (time.Duration, string, error) {
method Addr (line 769) | func (c *Client) Addr() string {
constant ConsistencyOne (line 124) | ConsistencyOne = "one"
constant ConsistencyAll (line 127) | ConsistencyAll = "all"
constant ConsistencyQuorum (line 130) | ConsistencyQuorum = "quorum"
constant ConsistencyAny (line 133) | ConsistencyAny = "any"
function NewClient (line 137) | func NewClient(c Config) (*Client, error) {
type Message (line 407) | type Message struct
type Result (line 413) | type Result struct
method MarshalJSON (line 420) | func (r *Result) MarshalJSON() ([]byte, error) {
method UnmarshalJSON (line 439) | func (r *Result) UnmarshalJSON(b []byte) error {
type Response (line 461) | type Response struct
method MarshalJSON (line 467) | func (r *Response) MarshalJSON() ([]byte, error) {
method UnmarshalJSON (line 484) | func (r *Response) UnmarshalJSON(b []byte) error {
method Error (line 505) | func (r *Response) Error() error {
type duplexReader (line 519) | type duplexReader struct
method Read (line 524) | func (r *duplexReader) Read(p []byte) (n int, err error) {
type ChunkedResponse (line 534) | type ChunkedResponse struct
method NextResponse (line 550) | func (r *ChunkedResponse) NextResponse() (*Response, error) {
function NewChunkedResponse (line 541) | func NewChunkedResponse(r io.Reader) *ChunkedResponse {
type Point (line 570) | type Point struct
method MarshalJSON (line 582) | func (p *Point) MarshalJSON() ([]byte, error) {
method MarshalString (line 604) | func (p *Point) MarshalString() string {
method UnmarshalJSON (line 616) | func (p *Point) UnmarshalJSON(b []byte) error {
function normalizeFields (line 674) | func normalizeFields(fields map[string]interface{}) map[string]interface...
type BatchPoints (line 699) | type BatchPoints struct
method UnmarshalJSON (line 710) | func (bp *BatchPoints) UnmarshalJSON(b []byte) error {
function checkPointTypes (line 777) | func checkPointTypes(p Point) error {
function EpochToTime (line 792) | func EpochToTime(epoch int64, precision string) (time.Time, error) {
function SetPrecision (line 817) | func SetPrecision(t time.Time, precision string) time.Time {
FILE: vendor/github.com/influxdata/influxdb/client/influxdb_test.go
function BenchmarkWrite (line 20) | func BenchmarkWrite(b *testing.B) {
function BenchmarkUnmarshalJSON2Tags (line 50) | func BenchmarkUnmarshalJSON2Tags(b *testing.B) {
function BenchmarkUnmarshalJSON10Tags (line 81) | func BenchmarkUnmarshalJSON10Tags(b *testing.B) {
function TestNewClient (line 120) | func TestNewClient(t *testing.T) {
function TestClient_Ping (line 128) | func TestClient_Ping(t *testing.T) {
function TestClient_Query (line 150) | func TestClient_Query(t *testing.T) {
function TestClient_ChunkedQuery (line 172) | func TestClient_ChunkedQuery(t *testing.T) {
function TestClient_BasicAuth (line 196) | func TestClient_BasicAuth(t *testing.T) {
function TestClient_Write (line 227) | func TestClient_Write(t *testing.T) {
function TestClient_UserAgent (line 252) | func TestClient_UserAgent(t *testing.T) {
function TestClient_Messages (line 324) | func TestClient_Messages(t *testing.T) {
function TestPoint_UnmarshalEpoch (line 362) | func TestPoint_UnmarshalEpoch(t *testing.T) {
function TestPoint_UnmarshalRFC (line 435) | func TestPoint_UnmarshalRFC(t *testing.T) {
function TestPoint_MarshalOmitempty (line 473) | func TestPoint_MarshalOmitempty(t *testing.T) {
function TestEpochToTime (line 519) | func TestEpochToTime(t *testing.T) {
function emptyTestServer (line 550) | func emptyTestServer() *httptest.Server {
function TestBatchPoints_Normal (line 559) | func TestBatchPoints_Normal(t *testing.T) {
function TestClient_Timeout (line 597) | func TestClient_Timeout(t *testing.T) {
function TestClient_NoTimeout (line 620) | func TestClient_NoTimeout(t *testing.T) {
function TestClient_WriteUint64 (line 646) | func TestClient_WriteUint64(t *testing.T) {
function TestClient_ParseConnectionString_IPv6 (line 676) | func TestClient_ParseConnectionString_IPv6(t *testing.T) {
function TestClient_CustomCertificates (line 687) | func TestClient_CustomCertificates(t *testing.T) {
function TestChunkedResponse (line 808) | func TestChunkedResponse(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/client/v2/client.go
type HTTPConfig (line 22) | type HTTPConfig struct
type BatchPointsConfig (line 49) | type BatchPointsConfig struct
type Client (line 64) | type Client interface
function NewHTTPClient (line 82) | func NewHTTPClient(conf HTTPConfig) (Client, error) {
type client (line 169) | type client struct
method Ping (line 119) | func (c *client) Ping(timeout time.Duration) (time.Duration, string, e...
method Close (line 162) | func (c *client) Close() error {
method Write (line 355) | func (c *client) Write(bp BatchPoints) error {
method Query (line 473) | func (c *client) Query(q Query) (*Response, error) {
type BatchPoints (line 183) | type BatchPoints interface
function NewBatchPoints (line 213) | func NewBatchPoints(conf BatchPointsConfig) (BatchPoints, error) {
type batchpoints (line 229) | type batchpoints struct
method AddPoint (line 237) | func (bp *batchpoints) AddPoint(p *Point) {
method AddPoints (line 241) | func (bp *batchpoints) AddPoints(ps []*Point) {
method Points (line 245) | func (bp *batchpoints) Points() []*Point {
method Precision (line 249) | func (bp *batchpoints) Precision() string {
method Database (line 253) | func (bp *batchpoints) Database() string {
method WriteConsistency (line 257) | func (bp *batchpoints) WriteConsistency() string {
method RetentionPolicy (line 261) | func (bp *batchpoints) RetentionPolicy() string {
method SetPrecision (line 265) | func (bp *batchpoints) SetPrecision(p string) error {
method SetDatabase (line 273) | func (bp *batchpoints) SetDatabase(db string) {
method SetWriteConsistency (line 277) | func (bp *batchpoints) SetWriteConsistency(wc string) {
method SetRetentionPolicy (line 281) | func (bp *batchpoints) SetRetentionPolicy(rp string) {
type Point (line 286) | type Point struct
method String (line 315) | func (p *Point) String() string {
method PrecisionString (line 321) | func (p *Point) PrecisionString(precison string) string {
method Name (line 326) | func (p *Point) Name() string {
method Tags (line 331) | func (p *Point) Tags() map[string]string {
method Time (line 336) | func (p *Point) Time() time.Time {
method UnixNano (line 341) | func (p *Point) UnixNano() int64 {
method Fields (line 346) | func (p *Point) Fields() (map[string]interface{}, error) {
function NewPoint (line 294) | func NewPoint(
function NewPointFrom (line 351) | func NewPointFrom(pt models.Point) *Point {
type Query (line 407) | type Query struct
function NewQuery (line 418) | func NewQuery(command, database, precision string) Query {
function NewQueryWithParameters (line 430) | func NewQueryWithParameters(command, database, precision string, paramet...
type Response (line 440) | type Response struct
method Error (line 447) | func (r *Response) Error() error {
type Message (line 460) | type Message struct
type Result (line 466) | type Result struct
type duplexReader (line 562) | type duplexReader struct
method Read (line 567) | func (r *duplexReader) Read(p []byte) (n int, err error) {
type ChunkedResponse (line 577) | type ChunkedResponse struct
method NextResponse (line 593) | func (r *ChunkedResponse) NextResponse() (*Response, error) {
function NewChunkedResponse (line 584) | func NewChunkedResponse(r io.Reader) *ChunkedResponse {
FILE: vendor/github.com/influxdata/influxdb/client/v2/client_test.go
function TestUDPClient_Query (line 15) | func TestUDPClient_Query(t *testing.T) {
function TestUDPClient_Ping (line 29) | func TestUDPClient_Ping(t *testing.T) {
function TestUDPClient_Write (line 43) | func TestUDPClient_Write(t *testing.T) {
function TestUDPClient_BadAddr (line 67) | func TestUDPClient_BadAddr(t *testing.T) {
function TestUDPClient_Batches (line 76) | func TestUDPClient_Batches(t *testing.T) {
function TestUDPClient_Split (line 103) | func TestUDPClient_Split(t *testing.T) {
type writeLogger (line 127) | type writeLogger struct
method Write (line 131) | func (w *writeLogger) Write(b []byte) (int, error) {
method Close (line 136) | func (w *writeLogger) Close() error { return nil }
function TestClient_Query (line 138) | func TestClient_Query(t *testing.T) {
function TestClient_ChunkedQuery (line 157) | func TestClient_ChunkedQuery(t *testing.T) {
function TestClient_BoundParameters (line 180) | func TestClient_BoundParameters(t *testing.T) {
function TestClient_BasicAuth (line 221) | func TestClient_BasicAuth(t *testing.T) {
function TestClient_Ping (line 251) | func TestClient_Ping(t *testing.T) {
function TestClient_Concurrent_Use (line 269) | func TestClient_Concurrent_Use(t *testing.T) {
function TestClient_Write (line 331) | func TestClient_Write(t *testing.T) {
function TestClient_UserAgent (line 353) | func TestClient_UserAgent(t *testing.T) {
function TestClient_PointString (line 423) | func TestClient_PointString(t *testing.T) {
function TestClient_PointWithoutTimeString (line 442) | func TestClient_PointWithoutTimeString(t *testing.T) {
function TestClient_PointName (line 458) | func TestClient_PointName(t *testing.T) {
function TestClient_PointTags (line 470) | func TestClient_PointTags(t *testing.T) {
function TestClient_PointUnixNano (line 481) | func TestClient_PointUnixNano(t *testing.T) {
function TestClient_PointFields (line 495) | func TestClient_PointFields(t *testing.T) {
function TestBatchPoints_PrecisionError (line 510) | func TestBatchPoints_PrecisionError(t *testing.T) {
function TestBatchPoints_SettersGetters (line 523) | func TestBatchPoints_SettersGetters(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/client/v2/example_test.go
function ExampleClient (line 13) | func ExampleClient() {
function ExampleClient_uDP (line 27) | func ExampleClient_uDP() {
function ExampleClient_Ping (line 59) | func ExampleClient_Ping() {
function ExampleClient_write (line 76) | func ExampleClient_write() {
function ExampleBatchPoints (line 110) | func ExampleBatchPoints() {
function ExampleBatchPoints_setters (line 132) | func ExampleBatchPoints_setters() {
function ExamplePoint (line 153) | func ExamplePoint() {
function ExamplePoint_withoutTime (line 167) | func ExamplePoint_withoutTime() {
function ExampleClient_write1000 (line 181) | func ExampleClient_write1000() {
function ExampleClient_query (line 234) | func ExampleClient_query() {
function ExampleClient_createDatabase (line 251) | func ExampleClient_createDatabase() {
FILE: vendor/github.com/influxdata/influxdb/client/v2/udp.go
constant UDPPayloadSize (line 13) | UDPPayloadSize = 512
type UDPConfig (line 17) | type UDPConfig struct
function NewUDPClient (line 29) | func NewUDPClient(conf UDPConfig) (Client, error) {
type udpclient (line 57) | type udpclient struct
method Close (line 53) | func (uc *udpclient) Close() error {
method Write (line 62) | func (uc *udpclient) Write(bp BatchPoints) error {
method Query (line 106) | func (uc *udpclient) Query(q Query) (*Response, error) {
method Ping (line 110) | func (uc *udpclient) Ping(timeout time.Duration) (time.Duration, strin...
FILE: vendor/github.com/influxdata/influxdb/cmd/influx/cli/cli.go
type CommandLine (line 36) | type CommandLine struct
method Run (line 74) | func (c *CommandLine) Run() error {
method mainLoop (line 208) | func (c *CommandLine) mainLoop() error {
method ParseCommand (line 237) | func (c *CommandLine) ParseCommand(cmd string) error {
method Connect (line 295) | func (c *CommandLine) Connect(cmd string) error {
method SetAuth (line 337) | func (c *CommandLine) SetAuth(cmd string) {
method clear (line 369) | func (c *CommandLine) clear(cmd string) {
method use (line 397) | func (c *CommandLine) use(cmd string) {
method databaseExists (line 427) | func (c *CommandLine) databaseExists(db string) bool {
method retentionPolicyExists (line 468) | func (c *CommandLine) retentionPolicyExists(db, rp string) bool {
method SetChunkSize (line 508) | func (c *CommandLine) SetChunkSize(cmd string) {
method SetPrecision (line 532) | func (c *CommandLine) SetPrecision(cmd string) {
method SetFormat (line 552) | func (c *CommandLine) SetFormat(cmd string) {
method SetWriteConsistency (line 567) | func (c *CommandLine) SetWriteConsistency(cmd string) {
method parseInto (line 636) | func (c *CommandLine) parseInto(stmt string) *client.BatchPoints {
method parseInsert (line 659) | func (c *CommandLine) parseInsert(stmt string) (*client.BatchPoints, e...
method Insert (line 680) | func (c *CommandLine) Insert(stmt string) error {
method query (line 698) | func (c *CommandLine) query(query string) client.Query {
method ExecuteQuery (line 708) | func (c *CommandLine) ExecuteQuery(query string) error {
method FormatResponse (line 750) | func (c *CommandLine) FormatResponse(response *client.Response, w io.W...
method writeJSON (line 763) | func (c *CommandLine) writeJSON(response *client.Response, w io.Writer) {
method writeCSV (line 793) | func (c *CommandLine) writeCSV(response *client.Response, w io.Writer) {
method writeColumns (line 815) | func (c *CommandLine) writeColumns(response *client.Response, w io.Wri...
method formatResults (line 853) | func (c *CommandLine) formatResults(result client.Result, separator st...
method Settings (line 945) | func (c *CommandLine) Settings() {
method help (line 967) | func (c *CommandLine) help() {
method history (line 994) | func (c *CommandLine) history() {
method saveHistory (line 1000) | func (c *CommandLine) saveHistory() {
method gopher (line 1009) | func (c *CommandLine) gopher() {
method Version (line 1067) | func (c *CommandLine) Version() {
method exit (line 1071) | func (c *CommandLine) exit() {
function New (line 64) | func New(version string) *CommandLine {
function isWhitespace (line 582) | func isWhitespace(ch rune) bool { return ch == ' ' || ch == '\t' || ch =...
function isLetter (line 585) | func isLetter(ch rune) bool { return (ch >= 'a' && ch <= 'z') || (ch >= ...
function isDigit (line 588) | func isDigit(ch rune) bool { return (ch >= '0' && ch <= '9') }
function isIdentFirstChar (line 591) | func isIdentFirstChar(ch rune) bool { return isLetter(ch) || ch == '_' }
function isNotIdentChar (line 594) | func isNotIdentChar(ch rune) bool { return !(isLetter(ch) || isDigit(ch)...
function parseUnquotedIdentifier (line 596) | func parseUnquotedIdentifier(stmt string) (string, string) {
function parseDoubleQuotedIdentifier (line 603) | func parseDoubleQuotedIdentifier(stmt string) (string, string) {
function parseNextIdentifier (line 622) | func parseNextIdentifier(stmt string) (ident, remainder string) {
function tagsEqual (line 778) | func tagsEqual(prev, current map[string]string) bool {
function columnsEqual (line 782) | func columnsEqual(prev, current []string) bool {
function headersEqual (line 786) | func headersEqual(prev, current models.Row) bool {
function interfaceToString (line 929) | func interfaceToString(v interface{}) string {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx/cli/cli_internal_test.go
function TestParseCommand_InsertInto (line 5) | func TestParseCommand_InsertInto(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx/cli/cli_test.go
constant CLIENT_VERSION (line 23) | CLIENT_VERSION = "y.y"
constant SERVER_VERSION (line 24) | SERVER_VERSION = "x.x"
function TestNewCLI (line 27) | func TestNewCLI(t *testing.T) {
function TestRunCLI (line 40) | func TestRunCLI(t *testing.T) {
function TestRunCLI_ExecuteInsert (line 60) | func TestRunCLI_ExecuteInsert(t *testing.T) {
function TestSetAuth (line 79) | func TestSetAuth(t *testing.T) {
function TestSetPrecision (line 98) | func TestSetPrecision(t *testing.T) {
function TestSetFormat (line 120) | func TestSetFormat(t *testing.T) {
function Test_SetChunked (line 135) | func Test_SetChunked(t *testing.T) {
function Test_SetChunkSize (line 166) | func Test_SetChunkSize(t *testing.T) {
function TestSetWriteConsistency (line 206) | func TestSetWriteConsistency(t *testing.T) {
function TestParseCommand_CommandsExist (line 235) | func TestParseCommand_CommandsExist(t *testing.T) {
function TestParseCommand_Connect (line 260) | func TestParseCommand_Connect(t *testing.T) {
function TestParseCommand_TogglePretty (line 280) | func TestParseCommand_TogglePretty(t *testing.T) {
function TestParseCommand_Exit (line 296) | func TestParseCommand_Exit(t *testing.T) {
function TestParseCommand_Quit (line 317) | func TestParseCommand_Quit(t *testing.T) {
function TestParseCommand_Use (line 338) | func TestParseCommand_Use(t *testing.T) {
function TestParseCommand_UseAuth (line 373) | func TestParseCommand_UseAuth(t *testing.T) {
function TestParseCommand_Consistency (line 427) | func TestParseCommand_Consistency(t *testing.T) {
function TestParseCommand_Insert (line 452) | func TestParseCommand_Insert(t *testing.T) {
function TestParseCommand_History (line 485) | func TestParseCommand_History(t *testing.T) {
function TestParseCommand_HistoryWithBlankCommand (line 516) | func TestParseCommand_HistoryWithBlankCommand(t *testing.T) {
function emptyTestServer (line 556) | func emptyTestServer() *httptest.Server {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx/cli/parser.go
function parseDatabaseAndRetentionPolicy (line 8) | func parseDatabaseAndRetentionPolicy(stmt []byte) (string, string, error) {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx/cli/parser_internal_test.go
function Test_parseDatabaseAndretentionPolicy (line 8) | func Test_parseDatabaseAndretentionPolicy(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx/main.go
constant defaultFormat (line 20) | defaultFormat = "column"
constant defaultPrecision (line 23) | defaultPrecision = "ns"
constant defaultPPS (line 27) | defaultPPS = 0
function init (line 30) | func init() {
function main (line 37) | func main() {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_stress/influx_stress.go
function main (line 22) | func main() {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/b1/reader.go
constant DefaultChunkSize (line 17) | DefaultChunkSize int = 1000
type Reader (line 27) | type Reader struct
method Open (line 64) | func (r *Reader) Open() error {
method Next (line 132) | func (r *Reader) Next() bool {
method Read (line 185) | func (r *Reader) Read() (string, []tsm1.Value, error) {
method Close (line 190) | func (r *Reader) Close() error {
function NewReader (line 46) | func NewReader(path string, stats *stats.Stats, chunkSize int) *Reader {
type cursor (line 196) | type cursor struct
method SeekTo (line 226) | func (c *cursor) SeekTo(seek int64) {
method Next (line 234) | func (c *cursor) Next() (key int64, value interface{}) {
function newCursor (line 208) | func newCursor(tx *bolt.Tx, series string, field string, dec *tsdb.Field...
type cursors (line 261) | type cursors
method Len (line 263) | func (a cursors) Len() int { return len(a) }
method Swap (line 264) | func (a cursors) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
method Less (line 265) | func (a cursors) Less(i, j int) bool {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/bz1/reader.go
constant DefaultChunkSize (line 21) | DefaultChunkSize = 1000
type Reader (line 24) | type Reader struct
method Open (line 61) | func (r *Reader) Open() error {
method Next (line 143) | func (r *Reader) Next() bool {
method Read (line 196) | func (r *Reader) Read() (string, []tsm1.Value, error) {
method Close (line 201) | func (r *Reader) Close() error {
function NewReader (line 43) | func NewReader(path string, stats *stats.Stats, chunkSize int) *Reader {
type cursor (line 207) | type cursor struct
method SeekTo (line 240) | func (c *cursor) SeekTo(seek int64) {
method seekBuf (line 266) | func (c *cursor) seekBuf(seek []byte) (key, value []byte) {
method Next (line 286) | func (c *cursor) Next() (int64, interface{}) {
method setBuf (line 322) | func (c *cursor) setBuf(block []byte) {
method read (line 341) | func (c *cursor) read() (key int64, value interface{}) {
function newCursor (line 223) | func newCursor(tx *bolt.Tx, series string, field string, dec *tsdb.Field...
type cursors (line 356) | type cursors
method Len (line 358) | func (a cursors) Len() int { return len(a) }
method Swap (line 359) | func (a cursors) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
method Less (line 360) | func (a cursors) Less(i, j int) bool {
constant entryHeaderSize (line 368) | entryHeaderSize = 8 + 4
function entryDataSize (line 371) | func entryDataSize(v []byte) int { return int(binary.BigEndian.Uint32(v[...
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/converter.go
constant maxBlocksPerKey (line 13) | maxBlocksPerKey = 65535
type KeyIterator (line 17) | type KeyIterator interface
type Converter (line 23) | type Converter struct
method Process (line 40) | func (c *Converter) Process(iter KeyIterator) error {
method nextTSMWriter (line 101) | func (c *Converter) nextTSMWriter() (tsm1.TSMWriter, error) {
function NewConverter (line 31) | func NewConverter(path string, sz uint32, stats *stats.Stats) *Converter {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/main.go
type ShardReader (line 31) | type ShardReader interface
constant tsmExt (line 38) | tsmExt = "tsm"
type options (line 52) | type options struct
method Parse (line 65) | func (o *options) Parse() error {
constant maxTSMSz (line 143) | maxTSMSz uint64 = 2 * 1024 * 1024 * 1024
function init (line 145) | func init() {
function main (line 150) | func main() {
function collectShards (line 242) | func collectShards(dbs []os.FileInfo) tsdb.ShardInfos {
function backupDatabase (line 264) | func backupDatabase(db string) error {
function convertShard (line 333) | func convertShard(si *tsdb.ShardInfo, tr *tracker) error {
type ParallelGroup (line 375) | type ParallelGroup
method Do (line 384) | func (p ParallelGroup) Do(f func()) {
function NewParallelGroup (line 379) | func NewParallelGroup(n int) ParallelGroup {
function yesno (line 392) | func yesno(b bool) string {
function allDBs (line 400) | func allDBs(dbs []string) string {
function isEnvSet (line 408) | func isEnvSet(name string) bool {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/stats/stats.go
type Stats (line 10) | type Stats struct
method AddPointsRead (line 23) | func (s *Stats) AddPointsRead(n int) {
method AddPointsWritten (line 28) | func (s *Stats) AddPointsWritten(n int) {
method AddTSMBytes (line 33) | func (s *Stats) AddTSMBytes(n uint32) {
method IncrTSMFileCount (line 38) | func (s *Stats) IncrTSMFileCount() {
method IncrNaN (line 43) | func (s *Stats) IncrNaN() {
method IncrInf (line 48) | func (s *Stats) IncrInf() {
method IncrFiltered (line 53) | func (s *Stats) IncrFiltered() {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tracker.go
type tracker (line 16) | type tracker struct
method Run (line 37) | func (t *tracker) Run() error {
method StatusUpdate (line 103) | func (t *tracker) StatusUpdate() {
method PrintStats (line 111) | func (t *tracker) PrintStats() {
function newTracker (line 27) | func newTracker(shards tsdb.ShardInfos, opts options) *tracker {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/codec.go
constant fieldFloat (line 11) | fieldFloat = 1
constant fieldInteger (line 12) | fieldInteger = 2
constant fieldBoolean (line 13) | fieldBoolean = 3
constant fieldString (line 14) | fieldString = 4
type FieldCodec (line 28) | type FieldCodec struct
method FieldIDByName (line 46) | func (f *FieldCodec) FieldIDByName(s string) (uint8, error) {
method DecodeByID (line 56) | func (f *FieldCodec) DecodeByID(targetID uint8, b []byte) (interface{}...
method DecodeByName (line 108) | func (f *FieldCodec) DecodeByName(name string, b []byte) (interface{},...
method FieldByName (line 117) | func (f *FieldCodec) FieldByName(name string) *Field {
function NewFieldCodec (line 35) | func NewFieldCodec(fields map[string]*Field) *FieldCodec {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/database.go
constant B1 (line 18) | B1 = iota
constant BZ1 (line 19) | BZ1
constant TSM1 (line 20) | TSM1
type EngineFormat (line 24) | type EngineFormat
method String (line 27) | func (e EngineFormat) String() string {
type ShardInfo (line 41) | type ShardInfo struct
method FormatAsString (line 50) | func (s *ShardInfo) FormatAsString() string {
method FullPath (line 55) | func (s *ShardInfo) FullPath(dataPath string) string {
type ShardInfos (line 60) | type ShardInfos
method Len (line 62) | func (s ShardInfos) Len() int { return len(s) }
method Swap (line 63) | func (s ShardInfos) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
method Less (line 64) | func (s ShardInfos) Less(i, j int) bool {
method Databases (line 77) | func (s ShardInfos) Databases() []string {
method FilterFormat (line 93) | func (s ShardInfos) FilterFormat(fmt EngineFormat) ShardInfos {
method Size (line 104) | func (s ShardInfos) Size() int64 {
method ExclusiveDatabases (line 115) | func (s ShardInfos) ExclusiveDatabases(exc []string) ShardInfos {
type Database (line 134) | type Database struct
method Name (line 144) | func (d *Database) Name() string {
method Path (line 149) | func (d *Database) Path() string {
method Shards (line 154) | func (d *Database) Shards() ([]*ShardInfo, error) {
function NewDatabase (line 139) | func NewDatabase(path string) *Database {
function shardFormat (line 202) | func shardFormat(path string) (EngineFormat, int64, error) {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/internal/meta.pb.go
type Series (line 28) | type Series struct
method Reset (line 34) | func (m *Series) Reset() { *m = Series{} }
method String (line 35) | func (m *Series) String() string { return proto.CompactTextString(m) }
method ProtoMessage (line 36) | func (*Series) ProtoMessage() {}
method GetKey (line 38) | func (m *Series) GetKey() string {
method GetTags (line 45) | func (m *Series) GetTags() []*Tag {
type Tag (line 52) | type Tag struct
method Reset (line 58) | func (m *Tag) Reset() { *m = Tag{} }
method String (line 59) | func (m *Tag) String() string { return proto.CompactTextString(m) }
method ProtoMessage (line 60) | func (*Tag) ProtoMessage() {}
method GetKey (line 62) | func (m *Tag) GetKey() string {
method GetValue (line 69) | func (m *Tag) GetValue() string {
type MeasurementFields (line 76) | type MeasurementFields struct
method Reset (line 81) | func (m *MeasurementFields) Reset() { *m = MeasurementFields{} }
method String (line 82) | func (m *MeasurementFields) String() string { return proto.CompactText...
method ProtoMessage (line 83) | func (*MeasurementFields) ProtoMessage() {}
method GetFields (line 85) | func (m *MeasurementFields) GetFields() []*Field {
type Field (line 92) | type Field struct
method Reset (line 99) | func (m *Field) Reset() { *m = Field{} }
method String (line 100) | func (m *Field) String() string { return proto.CompactTextString(m) }
method ProtoMessage (line 101) | func (*Field) ProtoMessage() {}
method GetID (line 103) | func (m *Field) GetID() int32 {
method GetName (line 110) | func (m *Field) GetName() string {
method GetType (line 117) | func (m *Field) GetType() int32 {
FILE: vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/types.go
type Field (line 14) | type Field struct
type MeasurementFields (line 21) | type MeasurementFields struct
method UnmarshalBinary (line 27) | func (m *MeasurementFields) UnmarshalBinary(buf []byte) error {
type Series (line 40) | type Series struct
function MeasurementFromSeriesKey (line 46) | func MeasurementFromSeriesKey(key string) string {
function DecodeKeyValue (line 51) | func DecodeKeyValue(field string, dec *FieldCodec, k, v []byte) (int64, ...
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/backup/backup.go
constant Suffix (line 25) | Suffix = ".pending"
constant Metafile (line 28) | Metafile = "meta"
constant BackupFilePattern (line 32) | BackupFilePattern = "%s.%s.%05d"
type Command (line 36) | type Command struct
method Run (line 58) | func (cmd *Command) Run(args ...string) error {
method parseFlags (line 94) | func (cmd *Command) parseFlags(args []string) (retentionPolicy, shardI...
method backupShard (line 133) | func (cmd *Command) backupShard(retentionPolicy string, shardID string...
method backupDatabase (line 161) | func (cmd *Command) backupDatabase(since time.Time) error {
method backupRetentionPolicy (line 179) | func (cmd *Command) backupRetentionPolicy(retentionPolicy string, sinc...
method backupResponsePaths (line 197) | func (cmd *Command) backupResponsePaths(response *snapshotter.Response...
method backupMetastore (line 219) | func (cmd *Command) backupMetastore() error {
method nextPath (line 248) | func (cmd *Command) nextPath(path string) (string, error) {
method downloadAndVerify (line 262) | func (cmd *Command) downloadAndVerify(req *snapshotter.Request, path s...
method download (line 296) | func (cmd *Command) download(req *snapshotter.Request, path string) er...
method requestInfo (line 335) | func (cmd *Command) requestInfo(request *snapshotter.Request) (*snapsh...
method printUsage (line 358) | func (cmd *Command) printUsage() {
function NewCommand (line 50) | func NewCommand() *Command {
function retentionAndShardFromPath (line 380) | func retentionAndShardFromPath(path string) (retention, shard string, er...
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/help/help.go
type Command (line 12) | type Command struct
method Run (line 24) | func (cmd *Command) Run(args ...string) error {
function NewCommand (line 17) | func NewCommand() *Command {
constant usage (line 29) | usage = `
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/main.go
function init (line 29) | func init() {
function main (line 42) | func main() {
type Main (line 53) | type Main struct
method Run (line 75) | func (m *Main) Run(args ...string) error {
function NewMain (line 62) | func NewMain() *Main {
type VersionCommand (line 146) | type VersionCommand struct
method Run (line 160) | func (cmd *VersionCommand) Run(args ...string) error {
function NewVersionCommand (line 152) | func NewVersionCommand() *VersionCommand {
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/restore/restore.go
type Command (line 23) | type Command struct
method Run (line 48) | func (cmd *Command) Run(args ...string) error {
method parseFlags (line 70) | func (cmd *Command) parseFlags(args []string) error {
method unpackMeta (line 117) | func (cmd *Command) unpackMeta() error {
method unpackShard (line 217) | func (cmd *Command) unpackShard(shardID string) error {
method unpackDatabase (line 236) | func (cmd *Command) unpackDatabase() error {
method unpackRetention (line 250) | func (cmd *Command) unpackRetention() error {
method unpackFiles (line 263) | func (cmd *Command) unpackFiles(pat string) error {
method unpackTar (line 285) | func (cmd *Command) unpackTar(tarFile string) error {
method unpackFile (line 309) | func (cmd *Command) unpackFile(tr *tar.Reader, fileName string) error {
method printUsage (line 332) | func (cmd *Command) printUsage() {
function NewCommand (line 39) | func NewCommand() *Command {
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/run/command.go
constant logo (line 19) | logo = `
type Command (line 32) | type Command struct
method Run (line 62) | func (cmd *Command) Run(args ...string) error {
method Close (line 129) | func (cmd *Command) Close() error {
method monitorServerErrors (line 138) | func (cmd *Command) monitorServerErrors() {
method ParseFlags (line 151) | func (cmd *Command) ParseFlags(args ...string) (Options, error) {
method writePIDFile (line 168) | func (cmd *Command) writePIDFile(path string) error {
method ParseConfig (line 191) | func (cmd *Command) ParseConfig(path string) (*Config, error) {
function NewCommand (line 50) | func NewCommand() *Command {
constant usage (line 208) | usage = `Runs the InfluxDB server.
type Options (line 228) | type Options struct
method GetConfigPath (line 242) | func (opt *Options) GetConfigPath() string {
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/run/config.go
constant DefaultBindAddress (line 36) | DefaultBindAddress = "127.0.0.1:8088"
type Config (line 40) | type Config struct
method FromTomlFile (line 118) | func (c *Config) FromTomlFile(fpath string) error {
method FromToml (line 128) | func (c *Config) FromToml(input string) error {
method Validate (line 143) | func (c *Config) Validate() error {
method ApplyEnvOverrides (line 188) | func (c *Config) ApplyEnvOverrides() error {
method applyEnvOverrides (line 192) | func (c *Config) applyEnvOverrides(prefix string, spec reflect.Value, ...
method Diagnostics (line 309) | func (c *Config) Diagnostics() (*diagnostics.Diagnostics, error) {
method diagnosticsClients (line 316) | func (c *Config) diagnosticsClients() map[string]diagnostics.Client {
method registerDiagnostics (line 352) | func (c *Config) registerDiagnostics(m *monitor.Monitor) {
method deregisterDiagnostics (line 359) | func (c *Config) deregisterDiagnostics(m *monitor.Monitor) {
function NewConfig (line 65) | func NewConfig() *Config {
function NewDemoConfig (line 89) | func NewDemoConfig() (*Config, error) {
function trimBOM (line 113) | func trimBOM(f []byte) []byte {
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/run/config_command.go
type PrintConfigCommand (line 13) | type PrintConfigCommand struct
method Run (line 29) | func (cmd *PrintConfigCommand) Run(args ...string) error {
method parseConfig (line 63) | func (cmd *PrintConfigCommand) parseConfig(path string) (*Config, erro...
function NewPrintConfigCommand (line 20) | func NewPrintConfigCommand() *PrintConfigCommand {
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/run/config_test.go
function TestConfig_Parse (line 13) | func TestConfig_Parse(t *testing.T) {
function TestConfig_Parse_EnvOverride (line 97) | func TestConfig_Parse_EnvOverride(t *testing.T) {
function TestConfig_ValidateNoServiceConfigured (line 220) | func TestConfig_ValidateNoServiceConfigured(t *testing.T) {
function TestConfig_ValidateMonitorStore_MetaOnly (line 237) | func TestConfig_ValidateMonitorStore_MetaOnly(t *testing.T) {
function TestConfig_DeprecatedOptions (line 257) | func TestConfig_DeprecatedOptions(t *testing.T) {
function TestConfig_InvalidSubsections (line 275) | func TestConfig_InvalidSubsections(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/cmd/influxd/run/server.go
function init (line 42) | func init() {
type BuildInfo (line 47) | type BuildInfo struct
type Server (line 57) | type Server struct
method Statistics (line 212) | func (s *Server) Statistics(tags map[string]string) []models.Statistic {
method appendSnapshotterService (line 226) | func (s *Server) appendSnapshotterService() {
method SetLogOutput (line 236) | func (s *Server) SetLogOutput(w io.Writer) {
method appendMonitorService (line 240) | func (s *Server) appendMonitorService() {
method appendRetentionPolicyService (line 244) | func (s *Server) appendRetentionPolicyService(c retention.Config) {
method appendHTTPDService (line 254) | func (s *Server) appendHTTPDService(c httpd.Config) {
method appendCollectdService (line 270) | func (s *Server) appendCollectdService(c collectd.Config) {
method appendOpenTSDBService (line 280) | func (s *Server) appendOpenTSDBService(c opentsdb.Config) error {
method appendGraphiteService (line 294) | func (s *Server) appendGraphiteService(c graphite.Config) error {
method appendPrecreatorService (line 310) | func (s *Server) appendPrecreatorService(c precreator.Config) error {
method appendUDPService (line 324) | func (s *Server) appendUDPService(c udp.Config) {
method appendContinuousQueryService (line 334) | func (s *Server) appendContinuousQueryService(c continuous_querier.Con...
method Err (line 345) | func (s *Server) Err() <-chan error { return s.err }
method Open (line 348) | func (s *Server) Open() error {
method Close (line 440) | func (s *Server) Close() error {
method startServerReporting (line 482) | func (s *Server) startServerReporting() {
method reportServer (line 498) | func (s *Server) reportServer() {
function NewServer (line 102) | func NewServer(c *Config, buildInfo *BuildInfo) (*Server, error) {
type Service (line 550) | type Service interface
function startProfile (line 563) | func startProfile(cpuprofile, memprofile string) {
function stopProfile (line 587) | func stopProfile() {
type monitorPointsWriter (line 602) | type monitorPointsWriter
method WritePoints (line 604) | func (pw *monitorPointsWriter) WritePoints(database, retentionPolicy s...
function raftDBExists (line 608) | func raftDBExists(dir string) error {
FILE: vendor/github.com/influxdata/influxdb/cmd/parse.go
function ParseCommandName (line 7) | func ParseCommandName(args []string) (string, []string) {
FILE: vendor/github.com/influxdata/influxdb/coordinator/config.go
constant DefaultWriteTimeout (line 15) | DefaultWriteTimeout = 10 * time.Second
constant DefaultMaxConcurrentQueries (line 19) | DefaultMaxConcurrentQueries = 0
constant DefaultMaxSelectPointN (line 23) | DefaultMaxSelectPointN = 0
constant DefaultMaxSelectSeriesN (line 27) | DefaultMaxSelectSeriesN = 0
type Config (line 31) | type Config struct
method Diagnostics (line 53) | func (c Config) Diagnostics() (*diagnostics.Diagnostics, error) {
function NewConfig (line 42) | func NewConfig() Config {
FILE: vendor/github.com/influxdata/influxdb/coordinator/config_test.go
function TestConfig_Parse (line 11) | func TestConfig_Parse(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/coordinator/meta_client.go
type MetaClient (line 11) | type MetaClient interface
FILE: vendor/github.com/influxdata/influxdb/coordinator/meta_client_test.go
type MetaClient (line 11) | type MetaClient struct
method CreateContinuousQuery (line 42) | func (c *MetaClient) CreateContinuousQuery(database, name, query strin...
method CreateDatabase (line 46) | func (c *MetaClient) CreateDatabase(name string) (*meta.DatabaseInfo, ...
method CreateDatabaseWithRetentionPolicy (line 50) | func (c *MetaClient) CreateDatabaseWithRetentionPolicy(name string, sp...
method CreateRetentionPolicy (line 54) | func (c *MetaClient) CreateRetentionPolicy(database string, spec *meta...
method DropShard (line 58) | func (c *MetaClient) DropShard(id uint64) error {
method CreateSubscription (line 62) | func (c *MetaClient) CreateSubscription(database, rp, name, mode strin...
method CreateUser (line 66) | func (c *MetaClient) CreateUser(name, password string, admin bool) (me...
method Database (line 70) | func (c *MetaClient) Database(name string) *meta.DatabaseInfo {
method Databases (line 74) | func (c *MetaClient) Databases() []meta.DatabaseInfo {
method DataNode (line 78) | func (c *MetaClient) DataNode(id uint64) (*meta.NodeInfo, error) {
method DataNodes (line 82) | func (c *MetaClient) DataNodes() ([]meta.NodeInfo, error) {
method DeleteDataNode (line 86) | func (c *MetaClient) DeleteDataNode(id uint64) error {
method DeleteMetaNode (line 90) | func (c *MetaClient) DeleteMetaNode(id uint64) error {
method DropContinuousQuery (line 94) | func (c *MetaClient) DropContinuousQuery(database, name string) error {
method DropDatabase (line 98) | func (c *MetaClient) DropDatabase(name string) error {
method DropRetentionPolicy (line 102) | func (c *MetaClient) DropRetentionPolicy(database, name string) error {
method DropSubscription (line 106) | func (c *MetaClient) DropSubscription(database, rp, name string) error {
method DropUser (line 110) | func (c *MetaClient) DropUser(name string) error {
method MetaNodes (line 114) | func (c *MetaClient) MetaNodes() ([]meta.NodeInfo, error) {
method RetentionPolicy (line 118) | func (c *MetaClient) RetentionPolicy(database, name string) (rpi *meta...
method SetAdminPrivilege (line 122) | func (c *MetaClient) SetAdminPrivilege(username string, admin bool) er...
method SetPrivilege (line 126) | func (c *MetaClient) SetPrivilege(username, database string, p influxq...
method ShardGroupsByTimeRange (line 130) | func (c *MetaClient) ShardGroupsByTimeRange(database, policy string, m...
method UpdateRetentionPolicy (line 134) | func (c *MetaClient) UpdateRetentionPolicy(database, name string, rpu ...
method UpdateUser (line 138) | func (c *MetaClient) UpdateUser(name, password string) error {
method UserPrivilege (line 142) | func (c *MetaClient) UserPrivilege(username, database string) (*influx...
method UserPrivileges (line 146) | func (c *MetaClient) UserPrivileges(username string) (map[string]influ...
method Users (line 150) | func (c *MetaClient) Users() []meta.UserInfo {
function DefaultMetaClientDatabaseFn (line 155) | func DefaultMetaClientDatabaseFn(name string) *meta.DatabaseInfo {
FILE: vendor/github.com/influxdata/influxdb/coordinator/points_writer.go
constant statWriteReq (line 20) | statWriteReq = "req"
constant statPointWriteReq (line 21) | statPointWriteReq = "pointReq"
constant statPointWriteReqLocal (line 22) | statPointWriteReqLocal = "pointReqLocal"
constant statWriteOK (line 23) | statWriteOK = "writeOk"
constant statWriteDrop (line 24) | statWriteDrop = "writeDrop"
constant statWriteTimeout (line 25) | statWriteTimeout = "writeTimeout"
constant statWriteErr (line 26) | statWriteErr = "writeError"
constant statSubWriteOK (line 27) | statSubWriteOK = "subWriteOk"
constant statSubWriteDrop (line 28) | statSubWriteDrop = "subWriteDrop"
type PointsWriter (line 44) | type PointsWriter struct
method Open (line 126) | func (w *PointsWriter) Open() error {
method Close (line 137) | func (w *PointsWriter) Close() error {
method WithLogger (line 153) | func (w *PointsWriter) WithLogger(log zap.Logger) {
method Statistics (line 171) | func (w *PointsWriter) Statistics(tags map[string]string) []models.Sta...
method MapShards (line 192) | func (w *PointsWriter) MapShards(wp *WritePointsRequest) (*ShardMappin...
method WritePointsInto (line 283) | func (w *PointsWriter) WritePointsInto(p *IntoWriteRequest) error {
method WritePoints (line 288) | func (w *PointsWriter) WritePoints(database, retentionPolicy string, c...
method WritePointsPrivileged (line 293) | func (w *PointsWriter) WritePointsPrivileged(database, retentionPolicy...
method writeToShard (line 358) | func (w *PointsWriter) writeToShard(shard *meta.ShardInfo, database, r...
type WritePointsRequest (line 72) | type WritePointsRequest struct
method AddPoint (line 79) | func (w *WritePointsRequest) AddPoint(name string, value interface{}, ...
function NewPointsWriter (line 90) | func NewPointsWriter() *PointsWriter {
type ShardMapping (line 100) | type ShardMapping struct
method MapPoint (line 117) | func (s *ShardMapping) MapPoint(shardInfo *meta.ShardInfo, p models.Po...
function NewShardMapping (line 108) | func NewShardMapping(n int) *ShardMapping {
type WriteStatistics (line 158) | type WriteStatistics struct
type sgList (line 246) | type sgList
method Covers (line 248) | func (l sgList) Covers(t time.Time) bool {
method ShardGroupAt (line 264) | func (l sgList) ShardGroupAt(t time.Time) *meta.ShardGroupInfo {
method Append (line 275) | func (l sgList) Append(sgi meta.ShardGroupInfo) sgList {
FILE: vendor/github.com/influxdata/influxdb/coordinator/points_writer_internal_test.go
function TestSgList_ShardGroupAt (line 8) | func TestSgList_ShardGroupAt(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/coordinator/points_writer_test.go
function TestPointsWriter_MapShards_One (line 21) | func TestPointsWriter_MapShards_One(t *testing.T) {
function TestPointsWriter_MapShards_AlterShardDuration (line 56) | func TestPointsWriter_MapShards_AlterShardDuration(t *testing.T) {
function TestPointsWriter_MapShards_Multiple (line 134) | func TestPointsWriter_MapShards_Multiple(t *testing.T) {
function TestPointsWriter_MapShards_Invalid (line 207) | func TestPointsWriter_MapShards_Invalid(t *testing.T) {
function TestPointsWriter_WritePoints (line 247) | func TestPointsWriter_WritePoints(t *testing.T) {
function TestPointsWriter_WritePoints_Dropped (line 373) | func TestPointsWriter_WritePoints_Dropped(t *testing.T) {
type fakePointsWriter (line 431) | type fakePointsWriter struct
method WritePointsInto (line 435) | func (f *fakePointsWriter) WritePointsInto(req *coordinator.IntoWriteR...
function TestBufferedPointsWriter (line 439) | func TestBufferedPointsWriter(t *testing.T) {
type fakeStore (line 551) | type fakeStore struct
method WriteToShard (line 556) | func (f *fakeStore) WriteToShard(shardID uint64, points []models.Point...
method CreateShard (line 560) | func (f *fakeStore) CreateShard(database, retentionPolicy string, shar...
function NewPointsWriterMetaClient (line 564) | func NewPointsWriterMetaClient() *PointsWriterMetaClient {
type PointsWriterMetaClient (line 593) | type PointsWriterMetaClient struct
method NodeID (line 601) | func (m PointsWriterMetaClient) NodeID() uint64 { return m.NodeIDFn() }
method RetentionPolicy (line 603) | func (m PointsWriterMetaClient) RetentionPolicy(database, name string)...
method CreateShardGroup (line 607) | func (m PointsWriterMetaClient) CreateShardGroup(database, policy stri...
method Database (line 611) | func (m PointsWriterMetaClient) Database(database string) *meta.Databa...
method ShardOwner (line 615) | func (m PointsWriterMetaClient) ShardOwner(shardID uint64) (string, st...
type Subscriber (line 619) | type Subscriber struct
method Points (line 623) | func (s Subscriber) Points() chan<- *coordinator.WritePointsRequest {
function NewRetentionPolicy (line 627) | func NewRetentionPolicy(name string, duration time.Duration, nodeCount i...
function AttachShardGroupInfo (line 658) | func AttachShardGroupInfo(rp *meta.RetentionPolicyInfo, owners []meta.Sh...
function nextShardID (line 681) | func nextShardID() uint64 {
FILE: vendor/github.com/influxdata/influxdb/coordinator/shard_mapper.go
type IteratorCreator (line 13) | type IteratorCreator interface
type ShardMapper (line 21) | type ShardMapper interface
type LocalShardMapper (line 26) | type LocalShardMapper struct
method MapShards (line 37) | func (e *LocalShardMapper) MapShards(sources influxql.Sources, opt *in...
method mapShards (line 48) | func (e *LocalShardMapper) mapShards(a *LocalShardMapping, sources inf...
type LocalShardMapping (line 89) | type LocalShardMapping struct
method FieldDimensions (line 93) | func (a *LocalShardMapping) FieldDimensions(m *influxql.Measurement) (...
method MapType (line 127) | func (a *LocalShardMapping) MapType(m *influxql.Measurement, field str...
method CreateIterator (line 155) | func (a *LocalShardMapping) CreateIterator(m *influxql.Measurement, op...
method Close (line 188) | func (a *LocalShardMapping) Close() error {
type Source (line 193) | type Source struct
FILE: vendor/github.com/influxdata/influxdb/coordinator/shard_mapper_test.go
function TestLocalShardMapper (line 14) | func TestLocalShardMapper(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/coordinator/statement_executor.go
type pointsWriter (line 24) | type pointsWriter interface
type StatementExecutor (line 29) | type StatementExecutor struct
method ExecuteStatement (line 54) | func (e *StatementExecutor) ExecuteStatement(stmt influxql.Statement, ...
method executeAlterRetentionPolicyStatement (line 203) | func (e *StatementExecutor) executeAlterRetentionPolicyStatement(stmt ...
method executeCreateContinuousQueryStatement (line 217) | func (e *StatementExecutor) executeCreateContinuousQueryStatement(q *i...
method executeCreateDatabaseStatement (line 246) | func (e *StatementExecutor) executeCreateDatabaseStatement(stmt *influ...
method executeCreateRetentionPolicyStatement (line 276) | func (e *StatementExecutor) executeCreateRetentionPolicyStatement(stmt...
method executeCreateSubscriptionStatement (line 299) | func (e *StatementExecutor) executeCreateSubscriptionStatement(q *infl...
method executeCreateUserStatement (line 303) | func (e *StatementExecutor) executeCreateUserStatement(q *influxql.Cre...
method executeDeleteSeriesStatement (line 308) | func (e *StatementExecutor) executeDeleteSeriesStatement(stmt *influxq...
method executeDropContinuousQueryStatement (line 320) | func (e *StatementExecutor) executeDropContinuousQueryStatement(q *inf...
method executeDropDatabaseStatement (line 327) | func (e *StatementExecutor) executeDropDatabaseStatement(stmt *influxq...
method executeDropMeasurementStatement (line 341) | func (e *StatementExecutor) executeDropMeasurementStatement(stmt *infl...
method executeDropSeriesStatement (line 350) | func (e *StatementExecutor) executeDropSeriesStatement(stmt *influxql....
method executeDropShardStatement (line 364) | func (e *StatementExecutor) executeDropShardStatement(stmt *influxql.D...
method executeDropRetentionPolicyStatement (line 374) | func (e *StatementExecutor) executeDropRetentionPolicyStatement(stmt *...
method executeDropSubscriptionStatement (line 392) | func (e *StatementExecutor) executeDropSubscriptionStatement(q *influx...
method executeDropUserStatement (line 396) | func (e *StatementExecutor) executeDropUserStatement(q *influxql.DropU...
method executeGrantStatement (line 400) | func (e *StatementExecutor) executeGrantStatement(stmt *influxql.Grant...
method executeGrantAdminStatement (line 404) | func (e *StatementExecutor) executeGrantAdminStatement(stmt *influxql....
method executeRevokeStatement (line 408) | func (e *StatementExecutor) executeRevokeStatement(stmt *influxql.Revo...
method executeRevokeAdminStatement (line 424) | func (e *StatementExecutor) executeRevokeAdminStatement(stmt *influxql...
method executeSetPasswordUserStatement (line 428) | func (e *StatementExecutor) executeSetPasswordUserStatement(q *influxq...
method executeSelectStatement (line 432) | func (e *StatementExecutor) executeSelectStatement(stmt *influxql.Sele...
method createIterators (line 526) | func (e *StatementExecutor) createIterators(stmt *influxql.SelectState...
method executeShowContinuousQueriesStatement (line 613) | func (e *StatementExecutor) executeShowContinuousQueriesStatement(stmt...
method executeShowDatabasesStatement (line 627) | func (e *StatementExecutor) executeShowDatabasesStatement(q *influxql....
method executeShowDiagnosticsStatement (line 641) | func (e *StatementExecutor) executeShowDiagnosticsStatement(stmt *infl...
method executeShowGrantsForUserStatement (line 669) | func (e *StatementExecutor) executeShowGrantsForUserStatement(q *influ...
method executeShowMeasurementsStatement (line 682) | func (e *StatementExecutor) executeShowMeasurementsStatement(q *influx...
method executeShowRetentionPoliciesStatement (line 730) | func (e *StatementExecutor) executeShowRetentionPoliciesStatement(q *i...
method executeShowShardsStatement (line 747) | func (e *StatementExecutor) executeShowShardsStatement(stmt *influxql....
method executeShowShardGroupsStatement (line 785) | func (e *StatementExecutor) executeShowShardGroupsStatement(stmt *infl...
method executeShowStatsStatement (line 813) | func (e *StatementExecutor) executeShowStatsStatement(stmt *influxql.S...
method executeShowSubscriptionsStatement (line 837) | func (e *StatementExecutor) executeShowSubscriptionsStatement(stmt *in...
method executeShowTagValues (line 855) | func (e *StatementExecutor) executeShowTagValues(q *influxql.ShowTagVa...
method executeShowUsersStatement (line 917) | func (e *StatementExecutor) executeShowUsersStatement(q *influxql.Show...
method writeInto (line 1004) | func (e *StatementExecutor) writeInto(w pointsWriter, stmt *influxql.S...
method NormalizeStatement (line 1079) | func (e *StatementExecutor) NormalizeStatement(stmt influxql.Statement...
method normalizeMeasurement (line 1110) | func (e *StatementExecutor) normalizeMeasurement(m *influxql.Measureme...
type BufferedPointsWriter (line 927) | type BufferedPointsWriter struct
method WritePointsInto (line 945) | func (w *BufferedPointsWriter) WritePointsInto(req *IntoWriteRequest) ...
method Flush (line 979) | func (w *BufferedPointsWriter) Flush() error {
method Len (line 999) | func (w *BufferedPointsWriter) Len() int { return len(w.buf) }
method Cap (line 1002) | func (w *BufferedPointsWriter) Cap() int { return cap(w.buf) }
function NewBufferedPointsWriter (line 935) | func NewBufferedPointsWriter(w pointsWriter, database, retentionPolicy s...
function convertRowToPoints (line 1040) | func convertRowToPoints(measurementName string, row *models.Row) ([]mode...
type IntoWriteRequest (line 1145) | type IntoWriteRequest struct
type TSDBStore (line 1152) | type TSDBStore interface
type LocalTSDBStore (line 1173) | type LocalTSDBStore struct
type ShardIteratorCreator (line 1178) | type ShardIteratorCreator interface
function joinUint64 (line 1183) | func joinUint64(a []uint64) string {
FILE: vendor/github.com/influxdata/influxdb/coordinator/statement_executor_test.go
constant DefaultDatabase (line 25) | DefaultDatabase = "db0"
constant DefaultRetentionPolicy (line 28) | DefaultRetentionPolicy = "rp0"
function TestQueryExecutor_ExecuteQuery_SelectStatement (line 32) | func TestQueryExecutor_ExecuteQuery_SelectStatement(t *testing.T) {
function TestQueryExecutor_ExecuteQuery_MaxSelectBucketsN (line 86) | func TestQueryExecutor_ExecuteQuery_MaxSelectBucketsN(t *testing.T) {
function TestStatementExecutor_NormalizeDropSeries (line 130) | func TestStatementExecutor_NormalizeDropSeries(t *testing.T) {
function TestStatementExecutor_NormalizeDeleteSeries (line 163) | func TestStatementExecutor_NormalizeDeleteSeries(t *testing.T) {
type mockAuthorizer (line 196) | type mockAuthorizer struct
method AuthorizeDatabase (line 200) | func (a *mockAuthorizer) AuthorizeDatabase(p influxql.Privilege, name ...
method AuthorizeQuery (line 204) | func (m *mockAuthorizer) AuthorizeQuery(database string, query *influx...
method AuthorizeSeriesRead (line 208) | func (m *mockAuthorizer) AuthorizeSeriesRead(database string, measurem...
method AuthorizeSeriesWrite (line 212) | func (m *mockAuthorizer) AuthorizeSeriesWrite(database string, measure...
function TestQueryExecutor_ExecuteQuery_ShowDatabases (line 216) | func TestQueryExecutor_ExecuteQuery_ShowDatabases(t *testing.T) {
type QueryExecutor (line 260) | type QueryExecutor struct
method ExecuteQuery (line 305) | func (e *QueryExecutor) ExecuteQuery(query, database string, chunkSize...
function NewQueryExecutor (line 271) | func NewQueryExecutor() *QueryExecutor {
function DefaultQueryExecutor (line 298) | func DefaultQueryExecutor() *QueryExecutor {
type TSDBStore (line 313) | type TSDBStore struct
method CreateShard (line 328) | func (s *TSDBStore) CreateShard(database, policy string, shardID uint6...
method WriteToShard (line 335) | func (s *TSDBStore) WriteToShard(shardID uint64, points []models.Point...
method RestoreShard (line 339) | func (s *TSDBStore) RestoreShard(id uint64, r io.Reader) error {
method BackupShard (line 343) | func (s *TSDBStore) BackupShard(id uint64, since time.Time, w io.Write...
method DeleteDatabase (line 347) | func (s *TSDBStore) DeleteDatabase(name string) error {
method DeleteMeasurement (line 351) | func (s *TSDBStore) DeleteMeasurement(database, name string) error {
method DeleteRetentionPolicy (line 355) | func (s *TSDBStore) DeleteRetentionPolicy(database, name string) error {
method DeleteShard (line 359) | func (s *TSDBStore) DeleteShard(id uint64) error {
method DeleteSeries (line 363) | func (s *TSDBStore) DeleteSeries(database string, sources []influxql.S...
method ShardGroup (line 367) | func (s *TSDBStore) ShardGroup(ids []uint64) tsdb.ShardGroup {
method Measurements (line 371) | func (s *TSDBStore) Measurements(database string, cond influxql.Expr) ...
method MeasurementNames (line 375) | func (s *TSDBStore) MeasurementNames(database string, cond influxql.Ex...
method TagValues (line 379) | func (s *TSDBStore) TagValues(database string, cond influxql.Expr) ([]...
type MockShard (line 383) | type MockShard struct
method MeasurementsByRegex (line 390) | func (sh *MockShard) MeasurementsByRegex(re *regexp.Regexp) []string {
method FieldDimensions (line 400) | func (sh *MockShard) FieldDimensions(measurements []string) (fields ma...
method MapType (line 404) | func (sh *MockShard) MapType(measurement, field string) influxql.DataT...
method CreateIterator (line 418) | func (sh *MockShard) CreateIterator(measurement string, opt influxql.I...
method ExpandSources (line 422) | func (sh *MockShard) ExpandSources(sources influxql.Sources) (influxql...
function MustParseQuery (line 427) | func MustParseQuery(s string) *influxql.Query {
function ReadAllResults (line 436) | func ReadAllResults(c <-chan *influxql.Result) []*influxql.Result {
type FloatIterator (line 445) | type FloatIterator struct
method Stats (line 450) | func (itr *FloatIterator) Stats() influxql.IteratorStats { return itr....
method Close (line 451) | func (itr *FloatIterator) Close() error { return nil }
method Next (line 454) | func (itr *FloatIterator) Next() (*influxql.FloatPoint, error) {
FILE: vendor/github.com/influxdata/influxdb/errors.go
function ErrDatabaseNotFound (line 15) | func ErrDatabaseNotFound(name string) error { return fmt.Errorf("databas...
function ErrRetentionPolicyNotFound (line 19) | func ErrRetentionPolicyNotFound(name string) error {
function IsAuthorizationError (line 24) | func IsAuthorizationError(err error) bool {
function IsClientError (line 32) | func IsClientError(err error) bool {
FILE: vendor/github.com/influxdata/influxdb/etc/burn-in/log.rb
type Log (line 1) | module Log
function info (line 2) | def self.info(msg)
function success (line 7) | def self.success(msg)
function failure (line 12) | def self.failure(msg)
function log (line 17) | def self.log(msg)
FILE: vendor/github.com/influxdata/influxdb/etc/burn-in/random_gaussian.rb
class RandomGaussian (line 1) | class RandomGaussian
method initialize (line 2) | def initialize(mean, stddev, rand_helper = lambda { Kernel.rand })
method rand (line 10) | def rand
method gaussian (line 23) | def self.gaussian(mean, stddev, rand)
FILE: vendor/github.com/influxdata/influxdb/importer/v8/importer.go
constant batchSize (line 17) | batchSize = 5000
type Config (line 20) | type Config struct
function NewConfig (line 30) | func NewConfig() Config {
type Importer (line 35) | type Importer struct
method Import (line 59) | func (i *Importer) Import() error {
method processDDL (line 142) | func (i *Importer) processDDL(scanner *bufio.Scanner) {
method processDML (line 160) | func (i *Importer) processDML(scanner *bufio.Scanner) {
method execute (line 183) | func (i *Importer) execute(command string) {
method queryExecutor (line 194) | func (i *Importer) queryExecutor(command string) {
method batchAccumulator (line 199) | func (i *Importer) batchAccumulator(line string, start time.Time) {
method batchWrite (line 214) | func (i *Importer) batchWrite() {
function NewImporter (line 50) | func NewImporter(config Config) *Importer {
FILE: vendor/github.com/influxdata/influxdb/influxql/ast.go
type DataType (line 20) | type DataType
method LessThan (line 84) | func (d DataType) LessThan(other DataType) bool {
method String (line 89) | func (d DataType) String() string {
constant Unknown (line 24) | Unknown DataType = 0
constant Float (line 26) | Float = 1
constant Integer (line 28) | Integer = 2
constant String (line 30) | String = 3
constant Boolean (line 32) | Boolean = 4
constant Time (line 34) | Time = 5
constant Duration (line 36) | Duration = 6
constant Tag (line 38) | Tag = 7
constant AnyField (line 40) | AnyField = 8
function InspectDataType (line 50) | func InspectDataType(v interface{}) DataType {
function InspectDataTypes (line 70) | func InspectDataTypes(a []interface{}) []DataType {
type Node (line 112) | type Node interface
type Query (line 190) | type Query struct
method node (line 119) | func (*Query) node() {}
method String (line 195) | func (q *Query) String() string { return q.Statements.String() }
type Statements (line 198) | type Statements
method node (line 120) | func (Statements) node() {}
method String (line 201) | func (a Statements) String() string {
type Statement (line 210) | type Statement interface
type HasDefaultDatabase (line 219) | type HasDefaultDatabase interface
type ExecutionPrivilege (line 229) | type ExecutionPrivilege struct
type ExecutionPrivileges (line 241) | type ExecutionPrivileges
type Expr (line 284) | type Expr interface
type Literal (line 308) | type Literal interface
type Source (line 326) | type Source interface
type Sources (line 337) | type Sources
method node (line 181) | func (Sources) node() {}
method Names (line 340) | func (a Sources) Names() []string {
method Filter (line 352) | func (a Sources) Filter(database, retentionPolicy string) []Source {
method HasSystemSource (line 369) | func (a Sources) HasSystemSource() bool {
method HasRegex (line 382) | func (a Sources) HasRegex() bool {
method String (line 395) | func (a Sources) String() string {
method Measurements (line 410) | func (a Sources) Measurements() []*Measurement {
method MarshalBinary (line 424) | func (a Sources) MarshalBinary() ([]byte, error) {
method UnmarshalBinary (line 434) | func (a *Sources) UnmarshalBinary(buf []byte) error {
function IsSystemName (line 451) | func IsSystemName(name string) bool {
type SortField (line 465) | type SortField struct
method node (line 179) | func (*SortField) node() {}
method String (line 474) | func (field *SortField) String() string {
type SortFields (line 489) | type SortFields
method node (line 180) | func (SortFields) node() {}
method String (line 492) | func (a SortFields) String() string {
type CreateDatabaseStatement (line 501) | type CreateDatabaseStatement struct
method node (line 124) | func (*CreateDatabaseStatement) node() {}
method stmt (line 245) | func (*CreateDatabaseStatement) stmt() {}
method String (line 522) | func (s *CreateDatabaseStatement) String() string {
method RequiredPrivileges (line 550) | func (s *CreateDatabaseStatement) RequiredPrivileges() (ExecutionPrivi...
type DropDatabaseStatement (line 555) | type DropDatabaseStatement struct
method node (line 132) | func (*DropDatabaseStatement) node() {}
method stmt (line 252) | func (*DropDatabaseStatement) stmt() {}
method String (line 561) | func (s *DropDatabaseStatement) String() string {
method RequiredPrivileges (line 569) | func (s *DropDatabaseStatement) RequiredPrivileges() (ExecutionPrivile...
type DropRetentionPolicyStatement (line 574) | type DropRetentionPolicyStatement struct
method node (line 134) | func (*DropRetentionPolicyStatement) node() {}
method stmt (line 254) | func (*DropRetentionPolicyStatement) stmt() {}
method String (line 583) | func (s *DropRetentionPolicyStatement) String() string {
method RequiredPrivileges (line 593) | func (s *DropRetentionPolicyStatement) RequiredPrivileges() (Execution...
method DefaultDatabase (line 598) | func (s *DropRetentionPolicyStatement) DefaultDatabase() string {
type CreateUserStatement (line 603) | type CreateUserStatement struct
method node (line 127) | func (*CreateUserStatement) node() {}
method stmt (line 248) | func (*CreateUserStatement) stmt() {}
method String (line 615) | func (s *CreateUserStatement) String() string {
method RequiredPrivileges (line 628) | func (s *CreateUserStatement) RequiredPrivileges() (ExecutionPrivilege...
type DropUserStatement (line 633) | type DropUserStatement struct
method node (line 138) | func (*DropUserStatement) node() {}
method stmt (line 257) | func (*DropUserStatement) stmt() {}
method String (line 639) | func (s *DropUserStatement) String() string {
method RequiredPrivileges (line 647) | func (s *DropUserStatement) RequiredPrivileges() (ExecutionPrivileges,...
type Privilege (line 652) | type Privilege
method String (line 669) | func (p Privilege) String() string {
constant NoPrivileges (line 656) | NoPrivileges Privilege = iota
constant ReadPrivilege (line 658) | ReadPrivilege
constant WritePrivilege (line 660) | WritePrivilege
constant AllPrivileges (line 662) | AllPrivileges
function NewPrivilege (line 666) | func NewPrivilege(p Privilege) *Privilege { return &p }
type GrantStatement (line 684) | type GrantStatement struct
method node (line 139) | func (*GrantStatement) node() {}
method stmt (line 258) | func (*GrantStatement) stmt() {}
method String (line 696) | func (s *GrantStatement) String() string {
method RequiredPrivileges (line 708) | func (s *GrantStatement) RequiredPrivileges() (ExecutionPrivileges, er...
method DefaultDatabase (line 713) | func (s *GrantStatement) DefaultDatabase() string {
type GrantAdminStatement (line 718) | type GrantAdminStatement struct
method node (line 140) | func (*GrantAdminStatement) node() {}
method stmt (line 259) | func (*GrantAdminStatement) stmt() {}
method String (line 724) | func (s *GrantAdminStatement) String() string {
method RequiredPrivileges (line 732) | func (s *GrantAdminStatement) RequiredPrivileges() (ExecutionPrivilege...
type KillQueryStatement (line 737) | type KillQueryStatement struct
method node (line 141) | func (*KillQueryStatement) node() {}
method stmt (line 260) | func (*KillQueryStatement) stmt() {}
method String (line 746) | func (s *KillQueryStatement) String() string {
method RequiredPrivileges (line 758) | func (s *KillQueryStatement) RequiredPrivileges() (ExecutionPrivileges...
type SetPasswordUserStatement (line 763) | type SetPasswordUserStatement struct
method node (line 145) | func (*SetPasswordUserStatement) node() {}
method stmt (line 281) | func (*SetPasswordUserStatement) stmt() {}
method String (line 772) | func (s *SetPasswordUserStatement) String() string {
method RequiredPrivileges (line 782) | func (s *SetPasswordUserStatement) RequiredPrivileges() (ExecutionPriv...
type RevokeStatement (line 787) | type RevokeStatement struct
method node (line 142) | func (*RevokeStatement) node() {}
method stmt (line 278) | func (*RevokeStatement) stmt() {}
method String (line 799) | func (s *RevokeStatement) String() string {
method RequiredPrivileges (line 811) | func (s *RevokeStatement) RequiredPrivileges() (ExecutionPrivileges, e...
method DefaultDatabase (line 816) | func (s *RevokeStatement) DefaultDatabase() string {
type RevokeAdminStatement (line 821) | type RevokeAdminStatement struct
method node (line 143) | func (*RevokeAdminStatement) node() {}
method stmt (line 279) | func (*RevokeAdminStatement) stmt() {}
method String (line 827) | func (s *RevokeAdminStatement) String() string {
method RequiredPrivileges (line 835) | func (s *RevokeAdminStatement) RequiredPrivileges() (ExecutionPrivileg...
type CreateRetentionPolicyStatement (line 840) | type CreateRetentionPolicyStatement struct
method node (line 125) | func (*CreateRetentionPolicyStatement) node() {}
method stmt (line 246) | func (*CreateRetentionPolicyStatement) stmt() {}
method String (line 861) | func (s *CreateRetentionPolicyStatement) String() string {
method RequiredPrivileges (line 882) | func (s *CreateRetentionPolicyStatement) RequiredPrivileges() (Executi...
method DefaultDatabase (line 887) | func (s *CreateRetentionPolicyStatement) DefaultDatabase() string {
type AlterRetentionPolicyStatement (line 892) | type AlterRetentionPolicyStatement struct
method node (line 122) | func (*AlterRetentionPolicyStatement) node() {}
method stmt (line 243) | func (*AlterRetentionPolicyStatement) stmt() {}
method String (line 913) | func (s *AlterRetentionPolicyStatement) String() string {
method RequiredPrivileges (line 943) | func (s *AlterRetentionPolicyStatement) RequiredPrivileges() (Executio...
method DefaultDatabase (line 948) | func (s *AlterRetentionPolicyStatement) DefaultDatabase() string {
type FillOption (line 953) | type FillOption
constant NullFill (line 957) | NullFill FillOption = iota
constant NoFill (line 959) | NoFill
constant NumberFill (line 961) | NumberFill
constant PreviousFill (line 963) | PreviousFill
constant LinearFill (line 965) | LinearFill
type SelectStatement (line 969) | type SelectStatement struct
method node (line 144) | func (*SelectStatement) node() {}
method stmt (line 280) | func (*SelectStatement) stmt() {}
method HasDerivative (line 1027) | func (s *SelectStatement) HasDerivative() bool {
method IsSimpleDerivative (line 1038) | func (s *SelectStatement) IsSimpleDerivative() bool {
method HasSelector (line 1051) | func (s *SelectStatement) HasSelector() bool {
method TimeAscending (line 1066) | func (s *SelectStatement) TimeAscending() bool {
method TimeFieldName (line 1071) | func (s *SelectStatement) TimeFieldName() string {
method Clone (line 1079) | func (s *SelectStatement) Clone() *SelectStatement {
method RewriteFields (line 1140) | func (s *SelectStatement) RewriteFields(m FieldMapper) (*SelectStateme...
method RewriteRegexConditions (line 1368) | func (s *SelectStatement) RewriteRegexConditions() {
method RewriteDistinct (line 1446) | func (s *SelectStatement) RewriteDistinct() {
method RewriteTimeFields (line 1465) | func (s *SelectStatement) RewriteTimeFields() {
method RewriteTimeCondition (line 1478) | func (s *SelectStatement) RewriteTimeCondition(now time.Time) error {
method ColumnNames (line 1514) | func (s *SelectStatement) ColumnNames() []string {
method FieldExprByName (line 1588) | func (s *SelectStatement) FieldExprByName(name string) (int, Expr) {
method Reduce (line 1605) | func (s *SelectStatement) Reduce(valuer Valuer) *SelectStatement {
method HasTimeFieldSpecified (line 1623) | func (s *SelectStatement) HasTimeFieldSpecified() bool {
method String (line 1633) | func (s *SelectStatement) String() string {
method RequiredPrivileges (line 1692) | func (s *SelectStatement) RequiredPrivileges() (ExecutionPrivileges, e...
method HasWildcard (line 1720) | func (s *SelectStatement) HasWildcard() bool {
method HasFieldWildcard (line 1725) | func (s *SelectStatement) HasFieldWildcard() (hasWildcard bool) {
method HasDimensionWildcard (line 1740) | func (s *SelectStatement) HasDimensionWildcard() bool {
method validate (line 1751) | func (s *SelectStatement) validate(tr targetRequirement) error {
method validateFields (line 1779) | func (s *SelectStatement) validateFields() error {
method validateDimensions (line 1796) | func (s *SelectStatement) validateDimensions() error {
method validSelectWithAggregate (line 1846) | func (s *SelectStatement) validSelectWithAggregate() error {
method validTopBottomAggr (line 1887) | func (s *SelectStatement) validTopBottomAggr(expr *Call) error {
method validPercentileAggr (line 1911) | func (s *SelectStatement) validPercentileAggr(expr *Call) error {
method validSampleAggr (line 1935) | func (s *SelectStatement) validSampleAggr(expr *Call) error {
method validateAggregates (line 1958) | func (s *SelectStatement) validateAggregates(tr targetRequirement) err...
method validateFill (line 2149) | func (s *SelectStatement) validateFill() error {
method validateTimeExpression (line 2165) | func (s *SelectStatement) validateTimeExpression() error {
method validateGroupByInterval (line 2197) | func (s *SelectStatement) validateGroupByInterval() error {
method HasDistinct (line 2234) | func (s *SelectStatement) HasDistinct() bool {
method validateDistinct (line 2248) | func (s *SelectStatement) validateDistinct() error {
method validateTopBottom (line 2270) | func (s *SelectStatement) validateTopBottom() error {
method GroupByInterval (line 2284) | func (s *SelectStatement) GroupByInterval() (time.Duration, error) {
method GroupByOffset (line 2315) | func (s *SelectStatement) GroupByOffset() (time.Duration, error) {
method SetTimeRange (line 2346) | func (s *SelectStatement) SetTimeRange(start, end time.Time) error {
method rewriteWithoutTimeDimensions (line 2365) | func (s *SelectStatement) rewriteWithoutTimeDimensions() string {
method NamesInWhere (line 2384) | func (s *SelectStatement) NamesInWhere() []string {
method NamesInSelect (line 2393) | func (s *SelectStatement) NamesInSelect() []string {
method NamesInDimension (line 2404) | func (s *SelectStatement) NamesInDimension() []string {
method FunctionCalls (line 2509) | func (s *SelectStatement) FunctionCalls() []*Call {
method FunctionCallsByPosition (line 2518) | func (s *SelectStatement) FunctionCallsByPosition() [][]*Call {
function cloneSources (line 1109) | func cloneSources(sources Sources) Sources {
function cloneSource (line 1117) | func cloneSource(s Source) Source {
function matchExactRegex (line 1401) | func matchExactRegex(v string) (string, bool) {
function LimitTagSets (line 2415) | func LimitTagSets(a []*TagSet, slimit, soffset int) []*TagSet {
function walkNames (line 2434) | func walkNames(exp Expr) []string {
function walkRefs (line 2459) | func walkRefs(exp Expr) []VarRef {
function ExprNames (line 2490) | func ExprNames(expr Expr) []VarRef {
function walkFunctionCalls (line 2527) | func walkFunctionCalls(exp Expr) []*Call {
function MatchSource (line 2547) | func MatchSource(sources Sources, name string) string {
type Target (line 2560) | type Target struct
method node (line 184) | func (*Target) node() {}
method String (line 2566) | func (t *Target) String() string {
type DeleteStatement (line 2582) | type DeleteStatement struct
method node (line 130) | func (*DeleteStatement) node() {}
method stmt (line 250) | func (*DeleteStatement) stmt() {}
method String (line 2591) | func (s *DeleteStatement) String() string {
method RequiredPrivileges (line 2603) | func (s *DeleteStatement) RequiredPrivileges() (ExecutionPrivileges, e...
method DefaultDatabase (line 2608) | func (s *DeleteStatement) DefaultDatabase() string {
type ShowSeriesStatement (line 2616) | type ShowSeriesStatement struct
method node (line 153) | func (*ShowSeriesStatement) node() {}
method stmt (line 268) | func (*ShowSeriesStatement) stmt() {}
method String (line 2639) | func (s *ShowSeriesStatement) String() string {
method RequiredPrivileges (line 2672) | func (s *ShowSeriesStatement) RequiredPrivileges() (ExecutionPrivilege...
method DefaultDatabase (line 2677) | func (s *ShowSeriesStatement) DefaultDatabase() string {
type DropSeriesStatement (line 2682) | type DropSeriesStatement struct
method node (line 135) | func (*DropSeriesStatement) node() {}
method stmt (line 255) | func (*DropSeriesStatement) stmt() {}
method String (line 2691) | func (s *DropSeriesStatement) String() string {
method RequiredPrivileges (line 2708) | func (s DropSeriesStatement) RequiredPrivileges() (ExecutionPrivileges...
type DeleteSeriesStatement (line 2713) | type DeleteSeriesStatement struct
method node (line 129) | func (*DeleteSeriesStatement) node() {}
method stmt (line 249) | func (*DeleteSeriesStatement) stmt() {}
method String (line 2722) | func (s *DeleteSeriesStatement) String() string {
method RequiredPrivileges (line 2739) | func (s DeleteSeriesStatement) RequiredPrivileges() (ExecutionPrivileg...
type DropShardStatement (line 2745) | type DropShardStatement struct
method node (line 136) | func (*DropShardStatement) node() {}
method stmt (line 272) | func (*DropShardStatement) stmt() {}
method String (line 2751) | func (s *DropShardStatement) String() string {
method RequiredPrivileges (line 2760) | func (s *DropShardStatement) RequiredPrivileges() (ExecutionPrivileges...
type ShowContinuousQueriesStatement (line 2765) | type ShowContinuousQueriesStatement struct
method node (line 146) | func (*ShowContinuousQueriesStatement) node() {}
method stmt (line 261) | func (*ShowContinuousQueriesStatement) stmt() {}
method String (line 2768) | func (s *ShowContinuousQueriesStatement) String() string { return "SHO...
method RequiredPrivileges (line 2771) | func (s *ShowContinuousQueriesStatement) RequiredPrivileges() (Executi...
type ShowGrantsForUserStatement (line 2776) | type ShowGrantsForUserStatement struct
method node (line 147) | func (*ShowGrantsForUserStatement) node() {}
method stmt (line 262) | func (*ShowGrantsForUserStatement) stmt() {}
method String (line 2782) | func (s *ShowGrantsForUserStatement) String() string {
method RequiredPrivileges (line 2791) | func (s *ShowGrantsForUserStatement) RequiredPrivileges() (ExecutionPr...
type ShowDatabasesStatement (line 2796) | type ShowDatabasesStatement struct
method node (line 148) | func (*ShowDatabasesStatement) node() {}
method stmt (line 263) | func (*ShowDatabasesStatement) stmt() {}
method String (line 2799) | func (s *ShowDatabasesStatement) String() string { return "SHOW DATABA...
method RequiredPrivileges (line 2802) | func (s *ShowDatabasesStatement) RequiredPrivileges() (ExecutionPrivil...
type CreateContinuousQueryStatement (line 2810) | type CreateContinuousQueryStatement struct
method node (line 123) | func (*CreateContinuousQueryStatement) node() {}
method stmt (line 244) | func (*CreateContinuousQueryStatement) stmt() {}
method String (line 2828) | func (s *CreateContinuousQueryStatement) String() string {
method DefaultDatabase (line 2846) | func (s *CreateContinuousQueryStatement) DefaultDatabase() string {
method RequiredPrivileges (line 2851) | func (s *CreateContinuousQueryStatement) RequiredPrivileges() (Executi...
method validate (line 2871) | func (s *CreateContinuousQueryStatement) validate() error {
type DropContinuousQueryStatement (line 2889) | type DropContinuousQueryStatement struct
method node (line 131) | func (*DropContinuousQueryStatement) node() {}
method stmt (line 251) | func (*DropContinuousQueryStatement) stmt() {}
method String (line 2895) | func (s *DropContinuousQueryStatement) String() string {
method RequiredPrivileges (line 2900) | func (s *DropContinuousQueryStatement) RequiredPrivileges() (Execution...
method DefaultDatabase (line 2905) | func (s *DropContinuousQueryStatement) DefaultDatabase() string {
type ShowMeasurementsStatement (line 2910) | type ShowMeasurementsStatement struct
method node (line 151) | func (*ShowMeasurementsStatement) node() {}
method stmt (line 265) | func (*ShowMeasurementsStatement) stmt() {}
method String (line 2932) | func (s *ShowMeasurementsStatement) String() string {
method RequiredPrivileges (line 2969) | func (s *ShowMeasurementsStatement) RequiredPrivileges() (ExecutionPri...
method DefaultDatabase (line 2974) | func (s *ShowMeasurementsStatement) DefaultDatabase() string {
type DropMeasurementStatement (line 2979) | type DropMeasurementStatement struct
method node (line 133) | func (*DropMeasurementStatement) node() {}
method stmt (line 253) | func (*DropMeasurementStatement) stmt() {}
method String (line 2985) | func (s *DropMeasurementStatement) String() string {
method RequiredPrivileges (line 2993) | func (s *DropMeasurementStatement) RequiredPrivileges() (ExecutionPriv...
type ShowQueriesStatement (line 2998) | type ShowQueriesStatement struct
method node (line 152) | func (*ShowQueriesStatement) node() {}
method stmt (line 266) | func (*ShowQueriesStatement) stmt() {}
method String (line 3001) | func (s *ShowQueriesStatement) String() string {
method RequiredPrivileges (line 3006) | func (s *ShowQueriesStatement) RequiredPrivileges() (ExecutionPrivileg...
type ShowRetentionPoliciesStatement (line 3011) | type ShowRetentionPoliciesStatement struct
method node (line 150) | func (*ShowRetentionPoliciesStatement) node() {}
method stmt (line 267) | func (*ShowRetentionPoliciesStatement) stmt() {}
method String (line 3017) | func (s *ShowRetentionPoliciesStatement) String() string {
method RequiredPrivileges (line 3028) | func (s *ShowRetentionPoliciesStatement) RequiredPrivileges() (Executi...
method DefaultDatabase (line 3033) | func (s *ShowRetentionPoliciesStatement) DefaultDatabase() string {
type ShowStatsStatement (line 3038) | type ShowStatsStatement struct
method node (line 156) | func (*ShowStatsStatement) node() {}
method stmt (line 271) | func (*ShowStatsStatement) stmt() {}
method String (line 3043) | func (s *ShowStatsStatement) String() string {
method RequiredPrivileges (line 3054) | func (s *ShowStatsStatement) RequiredPrivileges() (ExecutionPrivileges...
type ShowShardGroupsStatement (line 3059) | type ShowShardGroupsStatement struct
method node (line 154) | func (*ShowShardGroupsStatement) node() {}
method stmt (line 269) | func (*ShowShardGroupsStatement) stmt() {}
method String (line 3062) | func (s *ShowShardGroupsStatement) String() string { return "SHOW SHAR...
method RequiredPrivileges (line 3065) | func (s *ShowShardGroupsStatement) RequiredPrivileges() (ExecutionPriv...
type ShowShardsStatement (line 3070) | type ShowShardsStatement struct
method node (line 155) | func (*ShowShardsStatement) node() {}
method stmt (line 270) | func (*ShowShardsStatement) stmt() {}
method String (line 3073) | func (s *ShowShardsStatement) String() string { return "SHOW SHARDS" }
method RequiredPrivileges (line 3076) | func (s *ShowShardsStatement) RequiredPrivileges() (ExecutionPrivilege...
type ShowDiagnosticsStatement (line 3081) | type ShowDiagnosticsStatement struct
method node (line 158) | func (*ShowDiagnosticsStatement) node() {}
method stmt (line 274) | func (*ShowDiagnosticsStatement) stmt() {}
method String (line 3087) | func (s *ShowDiagnosticsStatement) String() string {
method RequiredPrivileges (line 3098) | func (s *ShowDiagnosticsStatement) RequiredPrivileges() (ExecutionPriv...
type CreateSubscriptionStatement (line 3103) | type CreateSubscriptionStatement struct
method node (line 126) | func (*CreateSubscriptionStatement) node() {}
method stmt (line 247) | func (*CreateSubscriptionStatement) stmt() {}
method String (line 3112) | func (s *CreateSubscriptionStatement) String() string {
method RequiredPrivileges (line 3134) | func (s *CreateSubscriptionStatement) RequiredPrivileges() (ExecutionP...
method DefaultDatabase (line 3139) | func (s *CreateSubscriptionStatement) DefaultDatabase() string {
type DropSubscriptionStatement (line 3144) | type DropSubscriptionStatement struct
method node (line 137) | func (*DropSubscriptionStatement) node() {}
method stmt (line 256) | func (*DropSubscriptionStatement) stmt() {}
method String (line 3151) | func (s *DropSubscriptionStatement) String() string {
method RequiredPrivileges (line 3156) | func (s *DropSubscriptionStatement) RequiredPrivileges() (ExecutionPri...
method DefaultDatabase (line 3161) | func (s *DropSubscriptionStatement) DefaultDatabase() string {
type ShowSubscriptionsStatement (line 3166) | type ShowSubscriptionsStatement struct
method node (line 157) | func (*ShowSubscriptionsStatement) node() {}
method stmt (line 273) | func (*ShowSubscriptionsStatement) stmt() {}
method String (line 3170) | func (s *ShowSubscriptionsStatement) String() string {
method RequiredPrivileges (line 3175) | func (s *ShowSubscriptionsStatement) RequiredPrivileges() (ExecutionPr...
type ShowTagKeysStatement (line 3180) | type ShowTagKeysStatement struct
method node (line 159) | func (*ShowTagKeysStatement) node() {}
method stmt (line 275) | func (*ShowTagKeysStatement) stmt() {}
method String (line 3208) | func (s *ShowTagKeysStatement) String() string {
method RequiredPrivileges (line 3248) | func (s *ShowTagKeysStatement) RequiredPrivileges() (ExecutionPrivileg...
method DefaultDatabase (line 3253) | func (s *ShowTagKeysStatement) DefaultDatabase() string {
type ShowTagValuesStatement (line 3258) | type ShowTagValuesStatement struct
method node (line 160) | func (*ShowTagValuesStatement) node() {}
method stmt (line 276) | func (*ShowTagValuesStatement) stmt() {}
method String (line 3287) | func (s *ShowTagValuesStatement) String() string {
method RequiredPrivileges (line 3327) | func (s *ShowTagValuesStatement) RequiredPrivileges() (ExecutionPrivil...
method DefaultDatabase (line 3332) | func (s *ShowTagValuesStatement) DefaultDatabase() string {
type ShowUsersStatement (line 3337) | type ShowUsersStatement struct
method node (line 161) | func (*ShowUsersStatement) node() {}
method stmt (line 277) | func (*ShowUsersStatement) stmt() {}
method String (line 3340) | func (s *ShowUsersStatement) String() string {
method RequiredPrivileges (line 3345) | func (s *ShowUsersStatement) RequiredPrivileges() (ExecutionPrivileges...
type ShowFieldKeysStatement (line 3350) | type ShowFieldKeysStatement struct
method node (line 149) | func (*ShowFieldKeysStatement) node() {}
method stmt (line 264) | func (*ShowFieldKeysStatement) stmt() {}
method String (line 3370) | func (s *ShowFieldKeysStatement) String() string {
method RequiredPrivileges (line 3398) | func (s *ShowFieldKeysStatement) RequiredPrivileges() (ExecutionPrivil...
method DefaultDatabase (line 3403) | func (s *ShowFieldKeysStatement) DefaultDatabase() string {
type Fields (line 3408) | type Fields
method node (line 171) | func (Fields) node() {}
method AliasNames (line 3412) | func (a Fields) AliasNames() []string {
method Names (line 3421) | func (a Fields) Names() []string {
method String (line 3439) | func (a Fields) String() string {
method Len (line 3489) | func (a Fields) Len() int { return len(a) }
method Less (line 3492) | func (a Fields) Less(i, j int) bool { return a[i].Name() < a[j].Name() }
method Swap (line 3495) | func (a Fields) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
type Field (line 3448) | type Field struct
method node (line 170) | func (*Field) node() {}
method Name (line 3455) | func (f *Field) Name() string {
method String (line 3479) | func (f *Field) String() string {
type Dimensions (line 3498) | type Dimensions
method node (line 167) | func (Dimensions) node() {}
method String (line 3501) | func (a Dimensions) String() string {
method Normalize (line 3511) | func (a Dimensions) Normalize() (time.Duration, []string) {
type Dimension (line 3529) | type Dimension struct
method node (line 166) | func (*Dimension) node() {}
method String (line 3534) | func (d *Dimension) String() string { return d.Expr.String() }
type Measurements (line 3537) | type Measurements
method node (line 173) | func (Measurements) node() {}
method String (line 3540) | func (a Measurements) String() string {
type Measurement (line 3549) | type Measurement struct
method node (line 172) | func (*Measurement) node() {}
method source (line 333) | func (*Measurement) source() {}
method String (line 3558) | func (m *Measurement) String() string {
function encodeMeasurement (line 3582) | func encodeMeasurement(mm *Measurement) *internal.Measurement {
function decodeMeasurement (line 3595) | func decodeMeasurement(pb *internal.Measurement) (*Measurement, error) {
type SubQuery (line 3615) | type SubQuery struct
method node (line 183) | func (*SubQuery) node() {}
method source (line 334) | func (*SubQuery) source() {}
method String (line 3620) | func (s *SubQuery) String() string {
type VarRef (line 3625) | type VarRef struct
method node (line 186) | func (*VarRef) node() {}
method expr (line 304) | func (*VarRef) expr() {}
method String (line 3631) | func (r *VarRef) String() string {
type VarRefs (line 3641) | type VarRefs
method Len (line 3644) | func (a VarRefs) Len() int { return len(a) }
method Less (line 3647) | func (a VarRefs) Less(i, j int) bool {
method Swap (line 3655) | func (a VarRefs) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
method Strings (line 3658) | func (a VarRefs) Strings() []string {
type Call (line 3667) | type Call struct
method node (line 165) | func (*Call) node() {}
method expr (line 293) | func (*Call) expr() {}
method String (line 3673) | func (c *Call) String() string {
type Distinct (line 3685) | type Distinct struct
method node (line 128) | func (*Distinct) node() {}
method expr (line 294) | func (*Distinct) expr() {}
method String (line 3691) | func (d *Distinct) String() string {
method NewCall (line 3696) | func (d *Distinct) NewCall() *Call {
type NumberLiteral (line 3706) | type NumberLiteral struct
method node (line 175) | func (*NumberLiteral) node() {}
method expr (line 298) | func (*NumberLiteral) expr() {}
method literal (line 319) | func (*NumberLiteral) literal() {}
method String (line 3711) | func (l *NumberLiteral) String() string { return strconv.FormatFloat(l...
type IntegerLiteral (line 3714) | type IntegerLiteral struct
method node (line 169) | func (*IntegerLiteral) node() {}
method expr (line 296) | func (*IntegerLiteral) expr() {}
method literal (line 317) | func (*IntegerLiteral) literal() {}
method String (line 3719) | func (l *IntegerLiteral) String() string { return fmt.Sprintf("%d", l....
type BooleanLiteral (line 3722) | type BooleanLiteral struct
method node (line 164) | func (*BooleanLiteral) node() {}
method expr (line 292) | func (*BooleanLiteral) expr() {}
method literal (line 315) | func (*BooleanLiteral) literal() {}
method String (line 3727) | func (l *BooleanLiteral) String() string {
function isTrueLiteral (line 3735) | func isTrueLiteral(expr Expr) bool {
function isFalseLiteral (line 3743) | func isFalseLiteral(expr Expr) bool {
type ListLiteral (line 3751) | type ListLiteral struct
method node (line 178) | func (*ListLiteral) node() {}
method expr (line 301) | func (*ListLiteral) expr() {}
method literal (line 321) | func (*ListLiteral) literal() {}
method String (line 3756) | func (s *ListLiteral) String() string {
type StringLiteral (line 3770) | type StringLiteral struct
method node (line 182) | func (*StringLiteral) node() {}
method expr (line 302) | func (*StringLiteral) expr() {}
method literal (line 322) | func (*StringLiteral) literal() {}
method String (line 3775) | func (l *StringLiteral) String() string { return QuoteString(l.Val) }
method IsTimeLiteral (line 3778) | func (l *StringLiteral) IsTimeLiteral() bool {
method ToTimeLiteral (line 3783) | func (l *StringLiteral) ToTimeLiteral(loc *time.Location) (*TimeLitera...
type TimeLiteral (line 3809) | type TimeLiteral struct
method node (line 185) | func (*TimeLiteral) node() {}
method expr (line 303) | func (*TimeLiteral) expr() {}
method literal (line 323) | func (*TimeLiteral) literal() {}
method String (line 3814) | func (l *TimeLiteral) String() string {
type DurationLiteral (line 3819) | type DurationLiteral struct
method node (line 168) | func (*DurationLiteral) node() {}
method expr (line 295) | func (*DurationLiteral) expr() {}
method literal (line 316) | func (*DurationLiteral) literal() {}
method String (line 3824) | func (l *DurationLiteral) String() string { return FormatDuration(l.Va...
type nilLiteral (line 3828) | type nilLiteral struct
method node (line 174) | func (*nilLiteral) node() {}
method expr (line 297) | func (*nilLiteral) expr() {}
method literal (line 318) | func (*nilLiteral) literal() {}
method String (line 3831) | func (l *nilLiteral) String() string { return `nil` }
type BinaryExpr (line 3834) | type BinaryExpr struct
method node (line 163) | func (*BinaryExpr) node() {}
method expr (line 291) | func (*BinaryExpr) expr() {}
method String (line 3841) | func (e *BinaryExpr) String() string {
method validate (line 3845) | func (e *BinaryExpr) validate() error {
type binaryExprValidator (line 3856) | type binaryExprValidator struct
method Visit (line 3862) | func (v *binaryExprValidator) Visit(n Node) Visitor {
function BinaryExprName (line 3893) | func BinaryExprName(expr *BinaryExpr) string {
type binaryExprNameVisitor (line 3899) | type binaryExprNameVisitor struct
method Visit (line 3903) | func (v *binaryExprNameVisitor) Visit(n Node) Visitor {
type ParenExpr (line 3915) | type ParenExpr struct
method node (line 176) | func (*ParenExpr) node() {}
method expr (line 299) | func (*ParenExpr) expr() {}
method String (line 3920) | func (e *ParenExpr) String() string { return fmt.Sprintf("(%s)", e.Exp...
type RegexLiteral (line 3923) | type RegexLiteral struct
method node (line 177) | func (*RegexLiteral) node() {}
method expr (line 300) | func (*RegexLiteral) expr() {}
method literal (line 320) | func (*RegexLiteral) literal() {}
method String (line 3928) | func (r *RegexLiteral) String() string {
function CloneRegexLiteral (line 3936) | func CloneRegexLiteral(r *RegexLiteral) *RegexLiteral {
type Wildcard (line 3950) | type Wildcard struct
method node (line 187) | func (*Wildcard) node() {}
method expr (line 305) | func (*Wildcard) expr() {}
method String (line 3955) | func (e *Wildcard) String() string {
function CloneExpr (line 3967) | func CloneExpr(expr Expr) Expr {
function HasTimeExpr (line 4007) | func HasTimeExpr(expr Expr) bool {
function OnlyTimeExpr (line 4026) | func OnlyTimeExpr(expr Expr) bool {
function TimeRange (line 4049) | func TimeRange(expr Expr, loc *time.Location) (min, max time.Time, err e...
function TimeRangeAsEpochNano (line 4113) | func TimeRangeAsEpochNano(expr Expr) (min, max int64, err error) {
function timeExprValue (line 4134) | func timeExprValue(ref Expr, lit Expr, loc *time.Location) (t time.Time,...
type Visitor (line 4172) | type Visitor interface
function Walk (line 4177) | func Walk(v Visitor, node Node) {
function WalkFunc (line 4281) | func WalkFunc(node Node, fn func(Node)) {
type walkFuncVisitor (line 4285) | type walkFuncVisitor
method Visit (line 4287) | func (fn walkFuncVisitor) Visit(n Node) Visitor { fn(n); return fn }
type Rewriter (line 4291) | type Rewriter interface
function Rewrite (line 4297) | func Rewrite(r Rewriter, node Node) Node {
function RewriteFunc (line 4357) | func RewriteFunc(node Node, fn func(Node) Node) Node {
type rewriterFunc (line 4361) | type rewriterFunc
method Rewrite (line 4363) | func (fn rewriterFunc) Rewrite(n Node) Node { return fn(n) }
function RewriteExpr (line 4367) | func RewriteExpr(expr Expr, fn func(Expr) Expr) Expr {
function Eval (line 4396) | func Eval(expr Expr, m map[string]interface{}) interface{} {
function evalBinaryExpr (line 4423) | func evalBinaryExpr(expr *BinaryExpr, m map[string]interface{}) interfac...
function EvalBool (line 4638) | func EvalBool(expr Expr, m map[string]interface{}) bool {
type TypeMapper (line 4644) | type TypeMapper interface
type nilTypeMapper (line 4648) | type nilTypeMapper struct
method MapType (line 4650) | func (nilTypeMapper) MapType(*Measurement, string) DataType { return U...
function EvalType (line 4653) | func EvalType(expr Expr, sources Sources, typmap TypeMapper) DataType {
function FieldDimensions (line 4727) | func FieldDimensions(sources Sources, m FieldMapper) (fields map[string]...
function Reduce (line 4769) | func Reduce(expr Expr, valuer Valuer) Expr {
function reduce (line 4779) | func reduce(expr Expr, valuer Valuer) Expr {
function reduceBinaryExpr (line 4800) | func reduceBinaryExpr(expr *BinaryExpr, valuer Valuer) Expr {
function reduceBinaryExprBooleanLHS (line 4857) | func reduceBinaryExprBooleanLHS(op Token, lhs *BooleanLiteral, rhs Expr)...
function reduceBinaryExprDurationLHS (line 4882) | func reduceBinaryExprDurationLHS(op Token, lhs *DurationLiteral, rhs Exp...
function reduceBinaryExprIntegerLHS (line 4946) | func reduceBinaryExprIntegerLHS(op Token, lhs *IntegerLiteral, rhs Expr,...
function reduceBinaryExprNilLHS (line 5017) | func reduceBinaryExprNilLHS(op Token, lhs *nilLiteral, rhs Expr) Expr {
function reduceBinaryExprNumberLHS (line 5025) | func reduceBinaryExprNumberLHS(op Token, lhs *NumberLiteral, rhs Expr) E...
function reduceBinaryExprStringLHS (line 5089) | func reduceBinaryExprStringLHS(op Token, lhs *StringLiteral, rhs Expr, l...
function reduceBinaryExprTimeLHS (line 5203) | func reduceBinaryExprTimeLHS(op Token, lhs *TimeLiteral, rhs Expr, loc *...
function reduceCall (line 5253) | func reduceCall(expr *Call, valuer Valuer) Expr {
function reduceParenExpr (line 5270) | func reduceParenExpr(expr *ParenExpr, valuer Valuer) Expr {
function reduceVarRef (line 5278) | func reduceVarRef(expr *VarRef, valuer Valuer) Expr {
type Valuer (line 5309) | type Valuer interface
type ZoneValuer (line 5315) | type ZoneValuer interface
type NowValuer (line 5321) | type NowValuer struct
method Value (line 5327) | func (v *NowValuer) Value(key string) (interface{}, bool) {
method Zone (line 5335) | func (v *NowValuer) Zone() *time.Location {
function ContainsVarRef (line 5343) | func ContainsVarRef(expr Expr) bool {
type containsVarRefVisitor (line 5349) | type containsVarRefVisitor struct
method Visit (line 5353) | func (v *containsVarRefVisitor) Visit(n Node) Visitor {
function IsSelector (line 5363) | func IsSelector(expr Expr) bool {
FILE: vendor/github.com/influxdata/influxdb/influxql/ast_test.go
function BenchmarkQuery_String (line 14) | func BenchmarkQuery_String(b *testing.B) {
function TestInspectDataType (line 23) | func TestInspectDataType(t *testing.T) {
function TestDataType_String (line 45) | func TestDataType_String(t *testing.T) {
function TestDataType_LessThan (line 65) | func TestDataType_LessThan(t *testing.T) {
function TestSelectStatement_GroupByInterval (line 115) | func TestSelectStatement_GroupByInterval(t *testing.T) {
function TestSelectStatement_SetTimeRange (line 133) | func TestSelectStatement_SetTimeRange(t *testing.T) {
function TestSelect_NamesInSelect (line 233) | func TestSelect_NamesInSelect(t *testing.T) {
function TestSelect_NamesInWhere (line 242) | func TestSelect_NamesInWhere(t *testing.T) {
function TestSelectStatement_HasWildcard (line 250) | func TestSelectStatement_HasWildcard(t *testing.T) {
function TestSelectStatement_RewriteFields (line 326) | func TestSelectStatement_RewriteFields(t *testing.T) {
function TestSelectStatement_RewriteRegexConditions (line 549) | func TestSelectStatement_RewriteRegexConditions(t *testing.T) {
function TestSelectStatement_RewriteTimeFields (line 618) | func TestSelectStatement_RewriteTimeFields(t *testing.T) {
function TestSelectStatement_IsRawQuerySet (line 668) | func TestSelectStatement_IsRawQuerySet(t *testing.T) {
function TestSelectStatement_HasDerivative (line 711) | func TestSelectStatement_HasDerivative(t *testing.T) {
function TestSelectStatement_IsSimpleDerivative (line 780) | func TestSelectStatement_IsSimpleDerivative(t *testing.T) {
function TestBinaryExprName (line 839) | func TestBinaryExprName(t *testing.T) {
function TestTimeRange (line 862) | func TestTimeRange(t *testing.T) {
function TestOnlyTimeExpr (line 942) | func TestOnlyTimeExpr(t *testing.T) {
function TestRewrite (line 982) | func TestRewrite(t *testing.T) {
function TestRewriteExpr (line 1002) | func TestRewriteExpr(t *testing.T) {
function TestParseString (line 1023) | func TestParseString(t *testing.T) {
function TestEval (line 1128) | func TestEval(t *testing.T) {
type EvalFixture (line 1187) | type EvalFixture
method MapType (line 1189) | func (e EvalFixture) MapType(measurement *influxql.Measurement, field ...
function TestEvalType (line 1197) | func TestEvalType(t *testing.T) {
function TestReduce (line 1272) | func TestReduce(t *testing.T) {
function Test_fieldsNames (line 1388) | func Test_fieldsNames(t *testing.T) {
function TestSelect_ColumnNames (line 1462) | func TestSelect_ColumnNames(t *testing.T) {
function TestSelect_Privileges (line 1522) | func TestSelect_Privileges(t *testing.T) {
function TestSelect_SubqueryPrivileges (line 1549) | func TestSelect_SubqueryPrivileges(t *testing.T) {
function TestShow_Privileges (line 1582) | func TestShow_Privileges(t *testing.T) {
function TestSources_Names (line 1655) | func TestSources_Names(t *testing.T) {
function TestSources_HasSystemSource (line 1674) | func TestSources_HasSystemSource(t *testing.T) {
function TestParse_Errors (line 1700) | func TestParse_Errors(t *testing.T) {
function Test_EnforceHasDefaultDatabase (line 1724) | func Test_EnforceHasDefaultDatabase(t *testing.T) {
type Valuer (line 1818) | type Valuer
method Value (line 1821) | func (o Valuer) Value(key string) (v interface{}, ok bool) {
function MustTimeRange (line 1827) | func MustTimeRange(expr influxql.Expr) (min, max time.Time) {
function mustParseTime (line 1836) | func mustParseTime(s string) time.Time {
function BenchmarkExprNames (line 1845) | func BenchmarkExprNames(b *testing.B) {
FILE: vendor/github.com/influxdata/influxdb/influxql/call_iterator.go
function NewCallIterator (line 36) | func NewCallIterator(input Iterator, opt IteratorOptions) (Iterator, err...
function newCountIterator (line 59) | func newCountIterator(input Iterator, opt IteratorOptions) (Iterator, er...
function FloatCountReduce (line 93) | func FloatCountReduce(prev *IntegerPoint, curr *FloatPoint) (int64, int6...
function IntegerCountReduce (line 101) | func IntegerCountReduce(prev, curr *IntegerPoint) (int64, int64, []inter...
function StringCountReduce (line 109) | func StringCountReduce(prev *IntegerPoint, curr *StringPoint) (int64, in...
function BooleanCountReduce (line 117) | func BooleanCountReduce(prev *IntegerPoint, curr *BooleanPoint) (int64, ...
function newMinIterator (line 125) | func newMinIterator(input Iterator, opt IteratorOptions) (Iterator, erro...
function FloatMinReduce (line 151) | func FloatMinReduce(prev, curr *FloatPoint) (int64, float64, []interface...
function IntegerMinReduce (line 159) | func IntegerMinReduce(prev, curr *IntegerPoint) (int64, int64, []interfa...
function BooleanMinReduce (line 167) | func BooleanMinReduce(prev, curr *BooleanPoint) (int64, bool, []interfac...
function newMaxIterator (line 175) | func newMaxIterator(input Iterator, opt IteratorOptions) (Iterator, erro...
function FloatMaxReduce (line 201) | func FloatMaxReduce(prev, curr *FloatPoint) (int64, float64, []interface...
function IntegerMaxReduce (line 209) | func IntegerMaxReduce(prev, curr *IntegerPoint) (int64, int64, []interfa...
function BooleanMaxReduce (line 217) | func BooleanMaxReduce(prev, curr *BooleanPoint) (int64, bool, []interfac...
function newSumIterator (line 225) | func newSumIterator(input Iterator, opt IteratorOptions) (Iterator, erro...
function FloatSumReduce (line 245) | func FloatSumReduce(prev, curr *FloatPoint) (int64, float64, []interface...
function IntegerSumReduce (line 253) | func IntegerSumReduce(prev, curr *IntegerPoint) (int64, int64, []interfa...
function newFirstIterator (line 261) | func newFirstIterator(input Iterator, opt IteratorOptions) (Iterator, er...
function FloatFirstReduce (line 293) | func FloatFirstReduce(prev, curr *FloatPoint) (int64, float64, []interfa...
function IntegerFirstReduce (line 301) | func IntegerFirstReduce(prev, curr *IntegerPoint) (int64, int64, []inter...
function StringFirstReduce (line 309) | func StringFirstReduce(prev, curr *StringPoint) (int64, string, []interf...
function BooleanFirstReduce (line 317) | func BooleanFirstReduce(prev, curr *BooleanPoint) (int64, bool, []interf...
function newLastIterator (line 325) | func newLastIterator(input Iterator, opt IteratorOptions) (Iterator, err...
function FloatLastReduce (line 357) | func FloatLastReduce(prev, curr *FloatPoint) (int64, float64, []interfac...
function IntegerLastReduce (line 365) | func IntegerLastReduce(prev, curr *IntegerPoint) (int64, int64, []interf...
function StringLastReduce (line 373) | func StringLastReduce(prev, curr *StringPoint) (int64, string, []interfa...
function BooleanLastReduce (line 381) | func BooleanLastReduce(prev, curr *BooleanPoint) (int64, bool, []interfa...
function NewDistinctIterator (line 389) | func NewDistinctIterator(input Iterator, opt IteratorOptions) (Iterator,...
function newMeanIterator (line 421) | func newMeanIterator(input Iterator, opt IteratorOptions) (Iterator, err...
function NewMedianIterator (line 441) | func NewMedianIterator(input Iterator, opt IteratorOptions) (Iterator, e...
function newMedianIterator (line 446) | func newMedianIterator(input Iterator, opt IteratorOptions) (Iterator, e...
function FloatMedianReduceSlice (line 466) | func FloatMedianReduceSlice(a []FloatPoint) []FloatPoint {
function IntegerMedianReduceSlice (line 484) | func IntegerMedianReduceSlice(a []IntegerPoint) []FloatPoint {
function NewModeIterator (line 502) | func NewModeIterator(input Iterator, opt IteratorOptions) (Iterator, err...
function FloatModeReduceSlice (line 534) | func FloatModeReduceSlice(a []FloatPoint) []FloatPoint {
function IntegerModeReduceSlice (line 568) | func IntegerModeReduceSlice(a []IntegerPoint) []IntegerPoint {
function StringModeReduceSlice (line 601) | func StringModeReduceSlice(a []StringPoint) []StringPoint {
function BooleanModeReduceSlice (line 635) | func BooleanModeReduceSlice(a []BooleanPoint) []BooleanPoint {
function newStddevIterator (line 661) | func newStddevIterator(input Iterator, opt IteratorOptions) (Iterator, e...
function FloatStddevReduceSlice (line 681) | func FloatStddevReduceSlice(a []FloatPoint) []FloatPoint {
function IntegerStddevReduceSlice (line 713) | func IntegerStddevReduceSlice(a []IntegerPoint) []FloatPoint {
function newSpreadIterator (line 739) | func newSpreadIterator(input Iterator, opt IteratorOptions) (Iterator, e...
function FloatSpreadReduceSlice (line 759) | func FloatSpreadReduceSlice(a []FloatPoint) []FloatPoint {
function IntegerSpreadReduceSlice (line 770) | func IntegerSpreadReduceSlice(a []IntegerPoint) []IntegerPoint {
function newTopIterator (line 784) | func newTopIterator(input Iterator, opt IteratorOptions, n int, keepTags...
function newBottomIterator (line 807) | func newBottomIterator(input Iterator, opt IteratorOptions, n int, keepT...
function newPercentileIterator (line 831) | func newPercentileIterator(input Iterator, opt IteratorOptions, percenti...
function NewFloatPercentileReduceSliceFunc (line 853) | func NewFloatPercentileReduceSliceFunc(percentile float64) FloatReduceSl...
function NewIntegerPercentileReduceSliceFunc (line 868) | func NewIntegerPercentileReduceSliceFunc(percentile float64) IntegerRedu...
function newDerivativeIterator (line 883) | func newDerivativeIterator(input Iterator, opt IteratorOptions, interval...
function newDifferenceIterator (line 903) | func newDifferenceIterator(input Iterator, opt IteratorOptions, isNonNeg...
function newElapsedIterator (line 923) | func newElapsedIterator(input Iterator, opt IteratorOptions, interval In...
function newMovingAverageIterator (line 955) | func newMovingAverageIterator(input Iterator, n int, opt IteratorOptions...
function newCumulativeSumIterator (line 975) | func newCumulativeSumIterator(input Iterator, opt IteratorOptions) (Iter...
function newHoltWintersIterator (line 995) | func newHoltWintersIterator(input Iterator, opt IteratorOptions, h, m in...
function NewSampleIterator (line 1015) | func NewSampleIterator(input Iterator, opt IteratorOptions, size int) (I...
function newSampleIterator (line 1020) | func newSampleIterator(input Iterator, opt IteratorOptions, size int) (I...
function newIntegralIterator (line 1052) | func newIntegralIterator(input Iterator, opt IteratorOptions, interval I...
FILE: vendor/github.com/influxdata/influxdb/influxql/call_iterator_test.go
function TestCallIterator_Count_Float (line 13) | func TestCallIterator_Count_Float(t *testing.T) {
function TestCallIterator_Count_Integer (line 48) | func TestCallIterator_Count_Integer(t *testing.T) {
function TestCallIterator_Count_String (line 83) | func TestCallIterator_Count_String(t *testing.T) {
function TestCallIterator_Count_Boolean (line 118) | func TestCallIterator_Count_Boolean(t *testing.T) {
function TestCallIterator_Min_Float (line 153) | func TestCallIterator_Min_Float(t *testing.T) {
function TestCallIterator_Min_Integer (line 187) | func TestCallIterator_Min_Integer(t *testing.T) {
function TestCallIterator_Min_Boolean (line 221) | func TestCallIterator_Min_Boolean(t *testing.T) {
function TestCallIterator_Max_Float (line 254) | func TestCallIterator_Max_Float(t *testing.T) {
function TestCallIterator_Max_Integer (line 287) | func TestCallIterator_Max_Integer(t *testing.T) {
function TestCallIterator_Max_Boolean (line 320) | func TestCallIterator_Max_Boolean(t *testing.T) {
function TestCallIterator_Sum_Float (line 353) | func TestCallIterator_Sum_Float(t *testing.T) {
function TestCallIterator_Sum_Integer (line 386) | func TestCallIterator_Sum_Integer(t *testing.T) {
function TestCallIterator_First_Float (line 419) | func TestCallIterator_First_Float(t *testing.T) {
function TestCallIterator_First_Integer (line 452) | func TestCallIterator_First_Integer(t *testing.T) {
function TestCallIterator_First_String (line 485) | func TestCallIterator_First_String(t *testing.T) {
function TestCallIterator_First_Boolean (line 518) | func TestCallIterator_First_Boolean(t *testing.T) {
function TestCallIterator_Last_Float (line 551) | func TestCallIterator_Last_Float(t *testing.T) {
function TestCallIterator_Last_Integer (line 584) | func TestCallIterator_Last_Integer(t *testing.T) {
function TestCallIterator_Last_String (line 617) | func TestCallIterator_Last_String(t *testing.T) {
function TestCallIterator_Last_Boolean (line 650) | func TestCallIterator_Last_Boolean(t *testing.T) {
function TestCallIterator_Mode_Float (line 683) | func TestCallIterator_Mode_Float(t *testing.T) {
function TestCallIterator_Mode_Integer (line 721) | func TestCallIterator_Mode_Integer(t *testing.T) {
function TestCallIterator_Mode_String (line 758) | func TestCallIterator_Mode_String(t *testing.T) {
function TestCallIterator_Mode_Boolean (line 796) | func TestCallIterator_Mode_Boolean(t *testing.T) {
function TestNewCallIterator_UnsupportedExprName (line 833) | func TestNewCallIterator_UnsupportedExprName(t *testing.T) {
function BenchmarkCountIterator_1K (line 846) | func BenchmarkCountIterator_1K(b *testing.B) { benchmarkCountIterator(...
function BenchmarkCountIterator_100K (line 847) | func BenchmarkCountIterator_100K(b *testing.B) { benchmarkCountIterator(...
function BenchmarkCountIterator_1M (line 848) | func BenchmarkCountIterator_1M(b *testing.B) { benchmarkCountIterator(...
function benchmarkCountIterator (line 850) | func benchmarkCountIterator(b *testing.B, pointN int) {
function benchmarkCallIterator (line 858) | func benchmarkCallIterator(b *testing.B, opt influxql.IteratorOptions, p...
function BenchmarkSampleIterator_1k (line 878) | func BenchmarkSampleIterator_1k(b *testing.B) { benchmarkSampleIterato...
function BenchmarkSampleIterator_100k (line 879) | func BenchmarkSampleIterator_100k(b *testing.B) { benchmarkSampleIterato...
function BenchmarkSampleIterator_1M (line 880) | func BenchmarkSampleIterator_1M(b *testing.B) { benchmarkSampleIterato...
function benchmarkSampleIterator (line 882) | func benchmarkSampleIterator(b *testing.B, pointN int) {
function BenchmarkDistinctIterator_1K (line 905) | func BenchmarkDistinctIterator_1K(b *testing.B) { benchmarkDistinctIte...
function BenchmarkDistinctIterator_100K (line 906) | func BenchmarkDistinctIterator_100K(b *testing.B) { benchmarkDistinctIte...
function BenchmarkDistinctIterator_1M (line 907) | func BenchmarkDistinctIterator_1M(b *testing.B) { benchmarkDistinctIte...
function benchmarkDistinctIterator (line 909) | func benchmarkDistinctIterator(b *testing.B, pointN int) {
function BenchmarkModeIterator_1K (line 932) | func BenchmarkModeIterator_1K(b *testing.B) { benchmarkModeIterator(b,...
function BenchmarkModeIterator_100K (line 933) | func BenchmarkModeIterator_100K(b *testing.B) { benchmarkModeIterator(b,...
function BenchmarkModeIterator_1M (line 934) | func BenchmarkModeIterator_1M(b *testing.B) { benchmarkModeIterator(b,...
function benchmarkModeIterator (line 936) | func benchmarkModeIterator(b *testing.B, pointN int) {
type FloatPointGenerator (line 959) | type FloatPointGenerator struct
method Close (line 965) | func (g *FloatPointGenerator) Close() error { return ...
method Stats (line 966) | func (g *FloatPointGenerator) Stats() influxql.IteratorStats { return ...
method Next (line 968) | func (g *FloatPointGenerator) Next() (*influxql.FloatPoint, error) {
function MustCallIterator (line 977) | func MustCallIterator(input influxql.Iterator, opt influxql.IteratorOpti...
FILE: vendor/github.com/influxdata/influxdb/influxql/cast.go
function castToFloat (line 3) | func castToFloat(v interface{}) float64 {
function castToInteger (line 14) | func castToInteger(v interface{}) int64 {
function castToString (line 25) | func castToString(v interface{}) string {
function castToBoolean (line 34) | func castToBoolean(v interface{}) bool {
FILE: vendor/github.com/influxdata/influxdb/influxql/emitter.go
type Emitter (line 11) | type Emitter struct
method Close (line 43) | func (e *Emitter) Close() error {
method Emit (line 48) | func (e *Emitter) Emit() (*models.Row, bool, error) {
method loadBuf (line 99) | func (e *Emitter) loadBuf() (t int64, name string, tags Tags, err erro...
method createRow (line 141) | func (e *Emitter) createRow(name string, tags Tags, values []interface...
method readAt (line 153) | func (e *Emitter) readAt(t int64, name string, tags Tags) []interface{} {
method readInto (line 167) | func (e *Emitter) readInto(t int64, name string, tags Tags, values []i...
method readIterator (line 191) | func (e *Emitter) readIterator(itr Iterator) (Point, error) {
function NewEmitter (line 32) | func NewEmitter(itrs []Iterator, ascending bool, chunkSize int) *Emitter {
FILE: vendor/github.com/influxdata/influxdb/influxql/emitter_test.go
function TestEmitter_Emit (line 14) | func TestEmitter_Emit(t *testing.T) {
function TestEmitter_ChunkSize (line 80) | func TestEmitter_ChunkSize(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/influxql/functions.gen.go
type FloatPointAggregator (line 16) | type FloatPointAggregator interface
type FloatBulkPointAggregator (line 21) | type FloatBulkPointAggregator interface
function AggregateFloatPoints (line 28) | func AggregateFloatPoints(a FloatPointAggregator, points []FloatPoint) {
type FloatPointEmitter (line 40) | type FloatPointEmitter interface
type FloatReduceFunc (line 45) | type FloatReduceFunc
type FloatFuncReducer (line 49) | type FloatFuncReducer struct
method AggregateFloat (line 61) | func (r *FloatFuncReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 77) | func (r *FloatFuncReducer) Emit() []FloatPoint {
function NewFloatFuncReducer (line 55) | func NewFloatFuncReducer(fn FloatReduceFunc, prev *FloatPoint) *FloatFun...
type FloatReduceSliceFunc (line 82) | type FloatReduceSliceFunc
type FloatSliceFuncReducer (line 86) | type FloatSliceFuncReducer struct
method AggregateFloat (line 98) | func (r *FloatSliceFuncReducer) AggregateFloat(p *FloatPoint) {
method AggregateFloatBulk (line 104) | func (r *FloatSliceFuncReducer) AggregateFloatBulk(points []FloatPoint) {
method Emit (line 110) | func (r *FloatSliceFuncReducer) Emit() []FloatPoint {
function NewFloatSliceFuncReducer (line 92) | func NewFloatSliceFuncReducer(fn FloatReduceSliceFunc) *FloatSliceFuncRe...
type FloatReduceIntegerFunc (line 115) | type FloatReduceIntegerFunc
type FloatFuncIntegerReducer (line 119) | type FloatFuncIntegerReducer struct
method AggregateFloat (line 131) | func (r *FloatFuncIntegerReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 147) | func (r *FloatFuncIntegerReducer) Emit() []IntegerPoint {
function NewFloatFuncIntegerReducer (line 125) | func NewFloatFuncIntegerReducer(fn FloatReduceIntegerFunc, prev *Integer...
type FloatReduceIntegerSliceFunc (line 152) | type FloatReduceIntegerSliceFunc
type FloatSliceFuncIntegerReducer (line 156) | type FloatSliceFuncIntegerReducer struct
method AggregateFloat (line 168) | func (r *FloatSliceFuncIntegerReducer) AggregateFloat(p *FloatPoint) {
method AggregateFloatBulk (line 174) | func (r *FloatSliceFuncIntegerReducer) AggregateFloatBulk(points []Flo...
method Emit (line 180) | func (r *FloatSliceFuncIntegerReducer) Emit() []IntegerPoint {
function NewFloatSliceFuncIntegerReducer (line 162) | func NewFloatSliceFuncIntegerReducer(fn FloatReduceIntegerSliceFunc) *Fl...
type FloatReduceStringFunc (line 185) | type FloatReduceStringFunc
type FloatFuncStringReducer (line 189) | type FloatFuncStringReducer struct
method AggregateFloat (line 201) | func (r *FloatFuncStringReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 217) | func (r *FloatFuncStringReducer) Emit() []StringPoint {
function NewFloatFuncStringReducer (line 195) | func NewFloatFuncStringReducer(fn FloatReduceStringFunc, prev *StringPoi...
type FloatReduceStringSliceFunc (line 222) | type FloatReduceStringSliceFunc
type FloatSliceFuncStringReducer (line 226) | type FloatSliceFuncStringReducer struct
method AggregateFloat (line 238) | func (r *FloatSliceFuncStringReducer) AggregateFloat(p *FloatPoint) {
method AggregateFloatBulk (line 244) | func (r *FloatSliceFuncStringReducer) AggregateFloatBulk(points []Floa...
method Emit (line 250) | func (r *FloatSliceFuncStringReducer) Emit() []StringPoint {
function NewFloatSliceFuncStringReducer (line 232) | func NewFloatSliceFuncStringReducer(fn FloatReduceStringSliceFunc) *Floa...
type FloatReduceBooleanFunc (line 255) | type FloatReduceBooleanFunc
type FloatFuncBooleanReducer (line 259) | type FloatFuncBooleanReducer struct
method AggregateFloat (line 271) | func (r *FloatFuncBooleanReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 287) | func (r *FloatFuncBooleanReducer) Emit() []BooleanPoint {
function NewFloatFuncBooleanReducer (line 265) | func NewFloatFuncBooleanReducer(fn FloatReduceBooleanFunc, prev *Boolean...
type FloatReduceBooleanSliceFunc (line 292) | type FloatReduceBooleanSliceFunc
type FloatSliceFuncBooleanReducer (line 296) | type FloatSliceFuncBooleanReducer struct
method AggregateFloat (line 308) | func (r *FloatSliceFuncBooleanReducer) AggregateFloat(p *FloatPoint) {
method AggregateFloatBulk (line 314) | func (r *FloatSliceFuncBooleanReducer) AggregateFloatBulk(points []Flo...
method Emit (line 320) | func (r *FloatSliceFuncBooleanReducer) Emit() []BooleanPoint {
function NewFloatSliceFuncBooleanReducer (line 302) | func NewFloatSliceFuncBooleanReducer(fn FloatReduceBooleanSliceFunc) *Fl...
type FloatDistinctReducer (line 325) | type FloatDistinctReducer struct
method AggregateFloat (line 335) | func (r *FloatDistinctReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 342) | func (r *FloatDistinctReducer) Emit() []FloatPoint {
function NewFloatDistinctReducer (line 330) | func NewFloatDistinctReducer() *FloatDistinctReducer {
type FloatElapsedReducer (line 352) | type FloatElapsedReducer struct
method AggregateFloat (line 368) | func (r *FloatElapsedReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 374) | func (r *FloatElapsedReducer) Emit() []IntegerPoint {
function NewFloatElapsedReducer (line 359) | func NewFloatElapsedReducer(interval Interval) *FloatElapsedReducer {
type FloatSampleReducer (line 385) | type FloatSampleReducer struct
method AggregateFloat (line 401) | func (r *FloatSampleReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 419) | func (r *FloatSampleReducer) Emit() []FloatPoint {
function NewFloatSampleReducer (line 393) | func NewFloatSampleReducer(size int) *FloatSampleReducer {
type IntegerPointAggregator (line 430) | type IntegerPointAggregator interface
type IntegerBulkPointAggregator (line 435) | type IntegerBulkPointAggregator interface
function AggregateIntegerPoints (line 442) | func AggregateIntegerPoints(a IntegerPointAggregator, points []IntegerPo...
type IntegerPointEmitter (line 454) | type IntegerPointEmitter interface
type IntegerReduceFloatFunc (line 459) | type IntegerReduceFloatFunc
type IntegerFuncFloatReducer (line 463) | type IntegerFuncFloatReducer struct
method AggregateInteger (line 475) | func (r *IntegerFuncFloatReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 491) | func (r *IntegerFuncFloatReducer) Emit() []FloatPoint {
function NewIntegerFuncFloatReducer (line 469) | func NewIntegerFuncFloatReducer(fn IntegerReduceFloatFunc, prev *FloatPo...
type IntegerReduceFloatSliceFunc (line 496) | type IntegerReduceFloatSliceFunc
type IntegerSliceFuncFloatReducer (line 500) | type IntegerSliceFuncFloatReducer struct
method AggregateInteger (line 512) | func (r *IntegerSliceFuncFloatReducer) AggregateInteger(p *IntegerPoin...
method AggregateIntegerBulk (line 518) | func (r *IntegerSliceFuncFloatReducer) AggregateIntegerBulk(points []I...
method Emit (line 524) | func (r *IntegerSliceFuncFloatReducer) Emit() []FloatPoint {
function NewIntegerSliceFuncFloatReducer (line 506) | func NewIntegerSliceFuncFloatReducer(fn IntegerReduceFloatSliceFunc) *In...
type IntegerReduceFunc (line 529) | type IntegerReduceFunc
type IntegerFuncReducer (line 533) | type IntegerFuncReducer struct
method AggregateInteger (line 545) | func (r *IntegerFuncReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 561) | func (r *IntegerFuncReducer) Emit() []IntegerPoint {
function NewIntegerFuncReducer (line 539) | func NewIntegerFuncReducer(fn IntegerReduceFunc, prev *IntegerPoint) *In...
type IntegerReduceSliceFunc (line 566) | type IntegerReduceSliceFunc
type IntegerSliceFuncReducer (line 570) | type IntegerSliceFuncReducer struct
method AggregateInteger (line 582) | func (r *IntegerSliceFuncReducer) AggregateInteger(p *IntegerPoint) {
method AggregateIntegerBulk (line 588) | func (r *IntegerSliceFuncReducer) AggregateIntegerBulk(points []Intege...
method Emit (line 594) | func (r *IntegerSliceFuncReducer) Emit() []IntegerPoint {
function NewIntegerSliceFuncReducer (line 576) | func NewIntegerSliceFuncReducer(fn IntegerReduceSliceFunc) *IntegerSlice...
type IntegerReduceStringFunc (line 599) | type IntegerReduceStringFunc
type IntegerFuncStringReducer (line 603) | type IntegerFuncStringReducer struct
method AggregateInteger (line 615) | func (r *IntegerFuncStringReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 631) | func (r *IntegerFuncStringReducer) Emit() []StringPoint {
function NewIntegerFuncStringReducer (line 609) | func NewIntegerFuncStringReducer(fn IntegerReduceStringFunc, prev *Strin...
type IntegerReduceStringSliceFunc (line 636) | type IntegerReduceStringSliceFunc
type IntegerSliceFuncStringReducer (line 640) | type IntegerSliceFuncStringReducer struct
method AggregateInteger (line 652) | func (r *IntegerSliceFuncStringReducer) AggregateInteger(p *IntegerPoi...
method AggregateIntegerBulk (line 658) | func (r *IntegerSliceFuncStringReducer) AggregateIntegerBulk(points []...
method Emit (line 664) | func (r *IntegerSliceFuncStringReducer) Emit() []StringPoint {
function NewIntegerSliceFuncStringReducer (line 646) | func NewIntegerSliceFuncStringReducer(fn IntegerReduceStringSliceFunc) *...
type IntegerReduceBooleanFunc (line 669) | type IntegerReduceBooleanFunc
type IntegerFuncBooleanReducer (line 673) | type IntegerFuncBooleanReducer struct
method AggregateInteger (line 685) | func (r *IntegerFuncBooleanReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 701) | func (r *IntegerFuncBooleanReducer) Emit() []BooleanPoint {
function NewIntegerFuncBooleanReducer (line 679) | func NewIntegerFuncBooleanReducer(fn IntegerReduceBooleanFunc, prev *Boo...
type IntegerReduceBooleanSliceFunc (line 706) | type IntegerReduceBooleanSliceFunc
type IntegerSliceFuncBooleanReducer (line 710) | type IntegerSliceFuncBooleanReducer struct
method AggregateInteger (line 722) | func (r *IntegerSliceFuncBooleanReducer) AggregateInteger(p *IntegerPo...
method AggregateIntegerBulk (line 728) | func (r *IntegerSliceFuncBooleanReducer) AggregateIntegerBulk(points [...
method Emit (line 734) | func (r *IntegerSliceFuncBooleanReducer) Emit() []BooleanPoint {
function NewIntegerSliceFuncBooleanReducer (line 716) | func NewIntegerSliceFuncBooleanReducer(fn IntegerReduceBooleanSliceFunc)...
type IntegerDistinctReducer (line 739) | type IntegerDistinctReducer struct
method AggregateInteger (line 749) | func (r *IntegerDistinctReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 756) | func (r *IntegerDistinctReducer) Emit() []IntegerPoint {
function NewIntegerDistinctReducer (line 744) | func NewIntegerDistinctReducer() *IntegerDistinctReducer {
type IntegerElapsedReducer (line 766) | type IntegerElapsedReducer struct
method AggregateInteger (line 782) | func (r *IntegerElapsedReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 788) | func (r *IntegerElapsedReducer) Emit() []IntegerPoint {
function NewIntegerElapsedReducer (line 773) | func NewIntegerElapsedReducer(interval Interval) *IntegerElapsedReducer {
type IntegerSampleReducer (line 799) | type IntegerSampleReducer struct
method AggregateInteger (line 815) | func (r *IntegerSampleReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 833) | func (r *IntegerSampleReducer) Emit() []IntegerPoint {
function NewIntegerSampleReducer (line 807) | func NewIntegerSampleReducer(size int) *IntegerSampleReducer {
type StringPointAggregator (line 844) | type StringPointAggregator interface
type StringBulkPointAggregator (line 849) | type StringBulkPointAggregator interface
function AggregateStringPoints (line 856) | func AggregateStringPoints(a StringPointAggregator, points []StringPoint) {
type StringPointEmitter (line 868) | type StringPointEmitter interface
type StringReduceFloatFunc (line 873) | type StringReduceFloatFunc
type StringFuncFloatReducer (line 877) | type StringFuncFloatReducer struct
method AggregateString (line 889) | func (r *StringFuncFloatReducer) AggregateString(p *StringPoint) {
method Emit (line 905) | func (r *StringFuncFloatReducer) Emit() []FloatPoint {
function NewStringFuncFloatReducer (line 883) | func NewStringFuncFloatReducer(fn StringReduceFloatFunc, prev *FloatPoin...
type StringReduceFloatSliceFunc (line 910) | type StringReduceFloatSliceFunc
type StringSliceFuncFloatReducer (line 914) | type StringSliceFuncFloatReducer struct
method AggregateString (line 926) | func (r *StringSliceFuncFloatReducer) AggregateString(p *StringPoint) {
method AggregateStringBulk (line 932) | func (r *StringSliceFuncFloatReducer) AggregateStringBulk(points []Str...
method Emit (line 938) | func (r *StringSliceFuncFloatReducer) Emit() []FloatPoint {
function NewStringSliceFuncFloatReducer (line 920) | func NewStringSliceFuncFloatReducer(fn StringReduceFloatSliceFunc) *Stri...
type StringReduceIntegerFunc (line 943) | type StringReduceIntegerFunc
type StringFuncIntegerReducer (line 947) | type StringFuncIntegerReducer struct
method AggregateString (line 959) | func (r *StringFuncIntegerReducer) AggregateString(p *StringPoint) {
method Emit (line 975) | func (r *StringFuncIntegerReducer) Emit() []IntegerPoint {
function NewStringFuncIntegerReducer (line 953) | func NewStringFuncIntegerReducer(fn StringReduceIntegerFunc, prev *Integ...
type StringReduceIntegerSliceFunc (line 980) | type StringReduceIntegerSliceFunc
type StringSliceFuncIntegerReducer (line 984) | type StringSliceFuncIntegerReducer struct
method AggregateString (line 996) | func (r *StringSliceFuncIntegerReducer) AggregateString(p *StringPoint) {
method AggregateStringBulk (line 1002) | func (r *StringSliceFuncIntegerReducer) AggregateStringBulk(points []S...
method Emit (line 1008) | func (r *StringSliceFuncIntegerReducer) Emit() []IntegerPoint {
function NewStringSliceFuncIntegerReducer (line 990) | func NewStringSliceFuncIntegerReducer(fn StringReduceIntegerSliceFunc) *...
type StringReduceFunc (line 1013) | type StringReduceFunc
type StringFuncReducer (line 1017) | type StringFuncReducer struct
method AggregateString (line 1029) | func (r *StringFuncReducer) AggregateString(p *StringPoint) {
method Emit (line 1045) | func (r *StringFuncReducer) Emit() []StringPoint {
function NewStringFuncReducer (line 1023) | func NewStringFuncReducer(fn StringReduceFunc, prev *StringPoint) *Strin...
type StringReduceSliceFunc (line 1050) | type StringReduceSliceFunc
type StringSliceFuncReducer (line 1054) | type StringSliceFuncReducer struct
method AggregateString (line 1066) | func (r *StringSliceFuncReducer) AggregateString(p *StringPoint) {
method AggregateStringBulk (line 1072) | func (r *StringSliceFuncReducer) AggregateStringBulk(points []StringPo...
method Emit (line 1078) | func (r *StringSliceFuncReducer) Emit() []StringPoint {
function NewStringSliceFuncReducer (line 1060) | func NewStringSliceFuncReducer(fn StringReduceSliceFunc) *StringSliceFun...
type StringReduceBooleanFunc (line 1083) | type StringReduceBooleanFunc
type StringFuncBooleanReducer (line 1087) | type StringFuncBooleanReducer struct
method AggregateString (line 1099) | func (r *StringFuncBooleanReducer) AggregateString(p *StringPoint) {
method Emit (line 1115) | func (r *StringFuncBooleanReducer) Emit() []BooleanPoint {
function NewStringFuncBooleanReducer (line 1093) | func NewStringFuncBooleanReducer(fn StringReduceBooleanFunc, prev *Boole...
type StringReduceBooleanSliceFunc (line 1120) | type StringReduceBooleanSliceFunc
type StringSliceFuncBooleanReducer (line 1124) | type StringSliceFuncBooleanReducer struct
method AggregateString (line 1136) | func (r *StringSliceFuncBooleanReducer) AggregateString(p *StringPoint) {
method AggregateStringBulk (line 1142) | func (r *StringSliceFuncBooleanReducer) AggregateStringBulk(points []S...
method Emit (line 1148) | func (r *StringSliceFuncBooleanReducer) Emit() []BooleanPoint {
function NewStringSliceFuncBooleanReducer (line 1130) | func NewStringSliceFuncBooleanReducer(fn StringReduceBooleanSliceFunc) *...
type StringDistinctReducer (line 1153) | type StringDistinctReducer struct
method AggregateString (line 1163) | func (r *StringDistinctReducer) AggregateString(p *StringPoint) {
method Emit (line 1170) | func (r *StringDistinctReducer) Emit() []StringPoint {
function NewStringDistinctReducer (line 1158) | func NewStringDistinctReducer() *StringDistinctReducer {
type StringElapsedReducer (line 1180) | type StringElapsedReducer struct
method AggregateString (line 1196) | func (r *StringElapsedReducer) AggregateString(p *StringPoint) {
method Emit (line 1202) | func (r *StringElapsedReducer) Emit() []IntegerPoint {
function NewStringElapsedReducer (line 1187) | func NewStringElapsedReducer(interval Interval) *StringElapsedReducer {
type StringSampleReducer (line 1213) | type StringSampleReducer struct
method AggregateString (line 1229) | func (r *StringSampleReducer) AggregateString(p *StringPoint) {
method Emit (line 1247) | func (r *StringSampleReducer) Emit() []StringPoint {
function NewStringSampleReducer (line 1221) | func NewStringSampleReducer(size int) *StringSampleReducer {
type BooleanPointAggregator (line 1258) | type BooleanPointAggregator interface
type BooleanBulkPointAggregator (line 1263) | type BooleanBulkPointAggregator interface
function AggregateBooleanPoints (line 1270) | func AggregateBooleanPoints(a BooleanPointAggregator, points []BooleanPo...
type BooleanPointEmitter (line 1282) | type BooleanPointEmitter interface
type BooleanReduceFloatFunc (line 1287) | type BooleanReduceFloatFunc
type BooleanFuncFloatReducer (line 1291) | type BooleanFuncFloatReducer struct
method AggregateBoolean (line 1303) | func (r *BooleanFuncFloatReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1319) | func (r *BooleanFuncFloatReducer) Emit() []FloatPoint {
function NewBooleanFuncFloatReducer (line 1297) | func NewBooleanFuncFloatReducer(fn BooleanReduceFloatFunc, prev *FloatPo...
type BooleanReduceFloatSliceFunc (line 1324) | type BooleanReduceFloatSliceFunc
type BooleanSliceFuncFloatReducer (line 1328) | type BooleanSliceFuncFloatReducer struct
method AggregateBoolean (line 1340) | func (r *BooleanSliceFuncFloatReducer) AggregateBoolean(p *BooleanPoin...
method AggregateBooleanBulk (line 1346) | func (r *BooleanSliceFuncFloatReducer) AggregateBooleanBulk(points []B...
method Emit (line 1352) | func (r *BooleanSliceFuncFloatReducer) Emit() []FloatPoint {
function NewBooleanSliceFuncFloatReducer (line 1334) | func NewBooleanSliceFuncFloatReducer(fn BooleanReduceFloatSliceFunc) *Bo...
type BooleanReduceIntegerFunc (line 1357) | type BooleanReduceIntegerFunc
type BooleanFuncIntegerReducer (line 1361) | type BooleanFuncIntegerReducer struct
method AggregateBoolean (line 1373) | func (r *BooleanFuncIntegerReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1389) | func (r *BooleanFuncIntegerReducer) Emit() []IntegerPoint {
function NewBooleanFuncIntegerReducer (line 1367) | func NewBooleanFuncIntegerReducer(fn BooleanReduceIntegerFunc, prev *Int...
type BooleanReduceIntegerSliceFunc (line 1394) | type BooleanReduceIntegerSliceFunc
type BooleanSliceFuncIntegerReducer (line 1398) | type BooleanSliceFuncIntegerReducer struct
method AggregateBoolean (line 1410) | func (r *BooleanSliceFuncIntegerReducer) AggregateBoolean(p *BooleanPo...
method AggregateBooleanBulk (line 1416) | func (r *BooleanSliceFuncIntegerReducer) AggregateBooleanBulk(points [...
method Emit (line 1422) | func (r *BooleanSliceFuncIntegerReducer) Emit() []IntegerPoint {
function NewBooleanSliceFuncIntegerReducer (line 1404) | func NewBooleanSliceFuncIntegerReducer(fn BooleanReduceIntegerSliceFunc)...
type BooleanReduceStringFunc (line 1427) | type BooleanReduceStringFunc
type BooleanFuncStringReducer (line 1431) | type BooleanFuncStringReducer struct
method AggregateBoolean (line 1443) | func (r *BooleanFuncStringReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1459) | func (r *BooleanFuncStringReducer) Emit() []StringPoint {
function NewBooleanFuncStringReducer (line 1437) | func NewBooleanFuncStringReducer(fn BooleanReduceStringFunc, prev *Strin...
type BooleanReduceStringSliceFunc (line 1464) | type BooleanReduceStringSliceFunc
type BooleanSliceFuncStringReducer (line 1468) | type BooleanSliceFuncStringReducer struct
method AggregateBoolean (line 1480) | func (r *BooleanSliceFuncStringReducer) AggregateBoolean(p *BooleanPoi...
method AggregateBooleanBulk (line 1486) | func (r *BooleanSliceFuncStringReducer) AggregateBooleanBulk(points []...
method Emit (line 1492) | func (r *BooleanSliceFuncStringReducer) Emit() []StringPoint {
function NewBooleanSliceFuncStringReducer (line 1474) | func NewBooleanSliceFuncStringReducer(fn BooleanReduceStringSliceFunc) *...
type BooleanReduceFunc (line 1497) | type BooleanReduceFunc
type BooleanFuncReducer (line 1501) | type BooleanFuncReducer struct
method AggregateBoolean (line 1513) | func (r *BooleanFuncReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1529) | func (r *BooleanFuncReducer) Emit() []BooleanPoint {
function NewBooleanFuncReducer (line 1507) | func NewBooleanFuncReducer(fn BooleanReduceFunc, prev *BooleanPoint) *Bo...
type BooleanReduceSliceFunc (line 1534) | type BooleanReduceSliceFunc
type BooleanSliceFuncReducer (line 1538) | type BooleanSliceFuncReducer struct
method AggregateBoolean (line 1550) | func (r *BooleanSliceFuncReducer) AggregateBoolean(p *BooleanPoint) {
method AggregateBooleanBulk (line 1556) | func (r *BooleanSliceFuncReducer) AggregateBooleanBulk(points []Boolea...
method Emit (line 1562) | func (r *BooleanSliceFuncReducer) Emit() []BooleanPoint {
function NewBooleanSliceFuncReducer (line 1544) | func NewBooleanSliceFuncReducer(fn BooleanReduceSliceFunc) *BooleanSlice...
type BooleanDistinctReducer (line 1567) | type BooleanDistinctReducer struct
method AggregateBoolean (line 1577) | func (r *BooleanDistinctReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1584) | func (r *BooleanDistinctReducer) Emit() []BooleanPoint {
function NewBooleanDistinctReducer (line 1572) | func NewBooleanDistinctReducer() *BooleanDistinctReducer {
type BooleanElapsedReducer (line 1594) | type BooleanElapsedReducer struct
method AggregateBoolean (line 1610) | func (r *BooleanElapsedReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1616) | func (r *BooleanElapsedReducer) Emit() []IntegerPoint {
function NewBooleanElapsedReducer (line 1601) | func NewBooleanElapsedReducer(interval Interval) *BooleanElapsedReducer {
type BooleanSampleReducer (line 1627) | type BooleanSampleReducer struct
method AggregateBoolean (line 1643) | func (r *BooleanSampleReducer) AggregateBoolean(p *BooleanPoint) {
method Emit (line 1661) | func (r *BooleanSampleReducer) Emit() []BooleanPoint {
function NewBooleanSampleReducer (line 1635) | func NewBooleanSampleReducer(size int) *BooleanSampleReducer {
FILE: vendor/github.com/influxdata/influxdb/influxql/functions.go
type FloatMeanReducer (line 13) | type FloatMeanReducer struct
method AggregateFloat (line 24) | func (r *FloatMeanReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 35) | func (r *FloatMeanReducer) Emit() []FloatPoint {
function NewFloatMeanReducer (line 19) | func NewFloatMeanReducer() *FloatMeanReducer {
type IntegerMeanReducer (line 44) | type IntegerMeanReducer struct
method AggregateInteger (line 55) | func (r *IntegerMeanReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 66) | func (r *IntegerMeanReducer) Emit() []FloatPoint {
function NewIntegerMeanReducer (line 50) | func NewIntegerMeanReducer() *IntegerMeanReducer {
type FloatDerivativeReducer (line 75) | type FloatDerivativeReducer struct
method AggregateFloat (line 95) | func (r *FloatDerivativeReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 108) | func (r *FloatDerivativeReducer) Emit() []FloatPoint {
function NewFloatDerivativeReducer (line 84) | func NewFloatDerivativeReducer(interval Interval, isNonNegative, ascendi...
type IntegerDerivativeReducer (line 132) | type IntegerDerivativeReducer struct
method AggregateInteger (line 152) | func (r *IntegerDerivativeReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 165) | func (r *IntegerDerivativeReducer) Emit() []FloatPoint {
function NewIntegerDerivativeReducer (line 141) | func NewIntegerDerivativeReducer(interval Interval, isNonNegative, ascen...
type FloatDifferenceReducer (line 189) | type FloatDifferenceReducer struct
method AggregateFloat (line 205) | func (r *FloatDifferenceReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 218) | func (r *FloatDifferenceReducer) Emit() []FloatPoint {
function NewFloatDifferenceReducer (line 196) | func NewFloatDifferenceReducer(isNonNegative bool) *FloatDifferenceReduc...
type IntegerDifferenceReducer (line 237) | type IntegerDifferenceReducer struct
method AggregateInteger (line 253) | func (r *IntegerDifferenceReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 266) | func (r *IntegerDifferenceReducer) Emit() []IntegerPoint {
function NewIntegerDifferenceReducer (line 244) | func NewIntegerDifferenceReducer(isNonNegative bool) *IntegerDifferenceR...
type FloatMovingAverageReducer (line 286) | type FloatMovingAverageReducer struct
method AggregateFloat (line 301) | func (r *FloatMovingAverageReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 319) | func (r *FloatMovingAverageReducer) Emit() []FloatPoint {
function NewFloatMovingAverageReducer (line 294) | func NewFloatMovingAverageReducer(n int) *FloatMovingAverageReducer {
type IntegerMovingAverageReducer (line 333) | type IntegerMovingAverageReducer struct
method AggregateInteger (line 348) | func (r *IntegerMovingAverageReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 366) | func (r *IntegerMovingAverageReducer) Emit() []FloatPoint {
function NewIntegerMovingAverageReducer (line 341) | func NewIntegerMovingAverageReducer(n int) *IntegerMovingAverageReducer {
type FloatCumulativeSumReducer (line 380) | type FloatCumulativeSumReducer struct
method AggregateFloat (line 391) | func (r *FloatCumulativeSumReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 397) | func (r *FloatCumulativeSumReducer) Emit() []FloatPoint {
function NewFloatCumulativeSumReducer (line 385) | func NewFloatCumulativeSumReducer() *FloatCumulativeSumReducer {
type IntegerCumulativeSumReducer (line 406) | type IntegerCumulativeSumReducer struct
method AggregateInteger (line 417) | func (r *IntegerCumulativeSumReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 423) | func (r *IntegerCumulativeSumReducer) Emit() []IntegerPoint {
function NewIntegerCumulativeSumReducer (line 411) | func NewIntegerCumulativeSumReducer() *IntegerCumulativeSumReducer {
type FloatHoltWintersReducer (line 435) | type FloatHoltWintersReducer struct
method aggregate (line 494) | func (r *FloatHoltWintersReducer) aggregate(time int64, value float64) {
method AggregateFloat (line 502) | func (r *FloatHoltWintersReducer) AggregateFloat(p *FloatPoint) {
method AggregateInteger (line 507) | func (r *FloatHoltWintersReducer) AggregateInteger(p *IntegerPoint) {
method roundTime (line 511) | func (r *FloatHoltWintersReducer) roundTime(t int64) int64 {
method Emit (line 523) | func (r *FloatHoltWintersReducer) Emit() []FloatPoint {
method next (line 659) | func (r *FloatHoltWintersReducer) next(alpha, beta, gamma, phi, phiH, ...
method forecast (line 668) | func (r *FloatHoltWintersReducer) forecast(h int, params []float64) []...
method sse (line 730) | func (r *FloatHoltWintersReducer) sse(params []float64) float64 {
method constrain (line 749) | func (r *FloatHoltWintersReducer) constrain(x []float64) {
constant hwWeight (line 463) | hwWeight = 0.5
constant hwDefaultEpsilon (line 465) | hwDefaultEpsilon = 1.0e-4
constant hwGuessLower (line 469) | hwGuessLower = 0.3
constant hwGuessUpper (line 471) | hwGuessUpper = 1.0
constant hwGuessStep (line 473) | hwGuessStep = 0.4
function NewFloatHoltWintersReducer (line 477) | func NewFloatHoltWintersReducer(h, m int, includeFitData bool, interval ...
type FloatIntegralReducer (line 781) | type FloatIntegralReducer struct
method AggregateFloat (line 804) | func (r *FloatIntegralReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 859) | func (r *FloatIntegralReducer) Emit() []FloatPoint {
method Close (line 873) | func (r *FloatIntegralReducer) Close() error {
function NewFloatIntegralReducer (line 794) | func NewFloatIntegralReducer(interval Interval, opt IteratorOptions) *Fl...
type IntegerIntegralReducer (line 885) | type IntegerIntegralReducer struct
method AggregateInteger (line 908) | func (r *IntegerIntegralReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 968) | func (r *IntegerIntegralReducer) Emit() []FloatPoint {
method Close (line 982) | func (r *IntegerIntegralReducer) Close() error {
function NewIntegerIntegralReducer (line 898) | func NewIntegerIntegralReducer(interval Interval, opt IteratorOptions) *...
type FloatTopReducer (line 993) | type FloatTopReducer struct
method AggregateFloat (line 1008) | func (r *FloatTopReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 1022) | func (r *FloatTopReducer) Emit() []FloatPoint {
function NewFloatTopReducer (line 997) | func NewFloatTopReducer(n int) *FloatTopReducer {
type IntegerTopReducer (line 1036) | type IntegerTopReducer struct
method AggregateInteger (line 1051) | func (r *IntegerTopReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 1065) | func (r *IntegerTopReducer) Emit() []IntegerPoint {
function NewIntegerTopReducer (line 1040) | func NewIntegerTopReducer(n int) *IntegerTopReducer {
type FloatBottomReducer (line 1079) | type FloatBottomReducer struct
method AggregateFloat (line 1094) | func (r *FloatBottomReducer) AggregateFloat(p *FloatPoint) {
method Emit (line 1108) | func (r *FloatBottomReducer) Emit() []FloatPoint {
function NewFloatBottomReducer (line 1083) | func NewFloatBottomReducer(n int) *FloatBottomReducer {
type IntegerBottomReducer (line 1122) | type IntegerBottomReducer struct
method AggregateInteger (line 1137) | func (r *IntegerBottomReducer) AggregateInteger(p *IntegerPoint) {
method Emit (line 1151) | func (r *IntegerBottomReducer) Emit() []IntegerPoint {
function NewIntegerBottomReducer (line 1126) | func NewIntegerBottomReducer(n int) *IntegerBottomReducer {
FILE: vendor/github.com/influxdata/influxdb/influxql/functions_test.go
function almostEqual (line 13) | func almostEqual(got, exp float64) bool {
function TestHoltWinters_AusTourists (line 17) | func TestHoltWinters_AusTourists(t *testing.T) {
function TestHoltWinters_AusTourists_Missing (line 103) | func TestHoltWinters_AusTourists_Missing(t *testing.T) {
function TestHoltWinters_USPopulation (line 182) | func TestHoltWinters_USPopulation(t *testing.T) {
function TestHoltWinters_USPopulation_Missing (line 255) | func TestHoltWinters_USPopulation_Missing(t *testing.T) {
function TestHoltWinters_RoundTime (line 324) | func TestHoltWinters_RoundTime(t *testing.T) {
function TestHoltWinters_MaxTime (line 360) | func TestHoltWinters_MaxTime(t *testing.T) {
function TestSample_AllSamplesSeen (line 395) | func TestSample_AllSamplesSeen(t *testing.T) {
function TestSample_SampleSizeLessThanNumPoints (line 456) | func TestSample_SampleSizeLessThanNumPoints(t *testing.T) {
function TestSample_SampleSizeGreaterThanNumPoints (line 476) | func TestSample_SampleSizeGreaterThanNumPoints(t *testing.T) {
FILE: vendor/github.com/influxdata/influxdb/influxql/internal/internal.pb.go
constant _ (line 36) | _ = proto.GoGoProtoPackageIsVersion2
type Point (line 38) | type Point struct
method Reset (line 53) | func (m *Point) Reset() { *m = Point{} }
method String (line 54) | func (m *Point) String() string { return proto.CompactTextS...
method ProtoMessage (line 55) | func (*Point) ProtoMessage() {}
method Descriptor (line 56) | func (*Point) Descriptor() ([]byte, []int) { return fileDescriptorInte...
method GetName (line 58) | func (m *Point) GetName() string {
method GetTags (line 65) | func (m *Point) GetTags() string {
method GetTime (line 72) | func (m *Point) GetTime() int64 {
method GetNil (line 79) | func (m *Point) GetNil() bool {
method GetAux (line 86) | func (m *Point) GetAux() []*Aux {
method GetAggregated (line 93) | func (m *Point) GetAggregated() uint32 {
method GetFloatValue (line 100) | func (m *Point) GetFloatValue() float64 {
method GetIntegerValue (line 107) | func (m *Point) GetIntegerValue() int64 {
method GetStringValue (line 114) | func (m *Point) GetStringValue() string {
method GetBooleanValue (line 121) | func (m *Point) GetBooleanValue() bool {
method GetStats (line 128) | func (m *Point) GetStats() *IteratorStats {
type Aux (line 135) | type Aux struct
method Reset (line 144) | func (m *Aux) Reset() { *m = Aux{} }
method String (line 145) | func (m *Aux) String() string { return proto.CompactTextStr...
method ProtoMessage (line 146) | func (*Aux) ProtoMessage() {}
method Descriptor (line 147) | func (*Aux) Descriptor() ([]byte, []int) { return fileDescriptorIntern...
method GetDataType (line 149) | func (m *Aux) GetDataType() int32 {
method GetFloatValue (line 156) | func (m *Aux) GetFloatValue() float64 {
method GetIntegerValue (line 163) | func (m *Aux) GetIntegerValue() int64 {
method GetStringValue (line 170) | func (m *Aux) GetStringValue() string {
method GetBooleanValue (line 177) | func (m *Aux) GetBooleanValue() bool {
type IteratorOptions (line 184) | type IteratorOptions struct
method Reset (line 209) | func (m *IteratorOptions) Reset() { *m = IteratorOp...
method String (line 210) | func (m *IteratorOptions) String() string { return proto.Co...
method ProtoMessage (line 211) | func (*IteratorOptions) ProtoMessage() {}
method Descriptor (line 212) | func (*IteratorOptions) Descriptor() ([]byte, []int) { return fileDesc...
method GetExpr (line 214) | func (m *IteratorOptions) GetExpr() string {
method GetAux (line 221) | func (m *IteratorOptions) GetAux() []string {
method GetFields (line 228) | func (m *IteratorOptions) GetFields() []*VarRef {
method GetSources (line 235) | func (m *IteratorOptions) GetSources() []*Measurement {
method GetInterval (line 242) | func (m *IteratorOptions) GetInterval() *Interval {
method GetDimensions (line 249) | func (m *IteratorOptions) GetDimensions() []string {
method GetGroupBy (line 256) | func (m *IteratorOptions) GetGroupBy() []string {
method GetFill (line 263) | func (m *IteratorOptions) GetFill() int32 {
method GetFillValue (line 270) | func (m *IteratorOptions) GetFillValue() float64 {
method GetCondition (line 277) | func (m *IteratorOptions) GetCondition() string {
method GetStartTime (line 284) | func (m *IteratorOptions) GetStartTime() int64 {
method GetEndTime (line 291) | func (m *IteratorOptions) GetEndTime() int64 {
method GetLocation (line 298) | func (m *IteratorOptions) GetLocation() string {
method GetAscending (line 305) | func (m *IteratorOptions) GetAscending() bool {
method GetLimit (line 312) | func (m *IteratorOptions) GetLimit() int64 {
method GetOffset (line 319) | func (m *IteratorOptions) GetOffset() int64 {
method GetSLimit (line 326) | func (m *IteratorOptions) GetSLimit() int64 {
method GetSOffset (line 333) | func (m *IteratorOptions) GetSOffset() int64 {
method GetDedupe (line 340) | func (m *IteratorOptions) GetDedupe() bool {
method GetMaxSeriesN (line 347) | func (m *IteratorOptions) GetMaxSeriesN() int64 {
method GetOrdered (line 354) | func (m *IteratorOptions) GetOrdered() bool {
type Measurements (line 361) | type Measurements struct
method Reset (line 366) | func (m *Measurements) Reset() { *m = Measurements{} }
method String (line 367) | func (m *Measurements) String() string { return proto.Compa...
method ProtoMessage (line 368) | func (*Measurements) ProtoMessage() {}
method Descriptor (line 369) | func (*Measurements) Descriptor() ([]byte, []int) { return fileDescrip...
method GetItems (line 371) | func (m *Measurements) GetItems() []*Measurement {
type Measurement (line 378) | type Measurement struct
method Reset (line 387) | func (m *Measurement) Reset() { *m = Measurement{} }
method String (line 388) | func (m *Measurement) String() string { return proto.Compac...
method ProtoMessage (line 389) | func (*Measurement) ProtoMessage() {}
method Descriptor (line 390) | func (*Measurement) Descriptor() ([]byte, []int) { return fileDescript...
method GetDatabase (line 392) | func (m *Measurement) GetDatabase() string {
method GetRetentionPolicy (line 399) | func (m *Measurement) GetRetentionPolicy() string {
method GetName (line 406) | func (m *Measurement) GetName() string {
method GetRegex (line 413) | func (m *Measurement) GetRegex() string {
method GetIsTarget (line 420) | func (m *Measurement) GetIsTarget() bool {
type Interval (line 427) | type Interval struct
method Reset (line 433) | func (m *Interval) Reset() { *m = Interval{} }
method String (line 434) | func (m *Interval) String() string { return proto.CompactTe...
method ProtoMessage (line 435) | func (*Interval) ProtoMessage() {}
method Descriptor (line 436) | func (*Interval) Descriptor() ([]byte, []int) { return fileDescriptorI...
method GetDuration (line 438) | func (m *Interval) GetDuration() int64 {
method GetOffset (line 445) | func (m *Interval) GetOffset() int64 {
type IteratorStats (line 452) | type IteratorStats struct
method Reset (line 458) | func (m *IteratorStats) Reset() { *m = IteratorStat...
method String (line 459) | func (m *IteratorStats) String() string { return proto.Comp...
method ProtoMessage (line 460) | func (*IteratorStats) ProtoMessage() {}
method Descriptor (line 461) | func (*IteratorStats) Descriptor() ([]byte, []int) { return fileDescri...
method GetSeriesN (line 463) | func (m *IteratorStats) GetSeriesN() int64 {
method GetPointN (line 470) | func (m *IteratorStats) GetPointN() int64 {
type VarRef (line 477) | type VarRef struct
method Reset (line 483) | func (m *VarRef) Reset() { *m = VarRef{} }
method String (line 484) | func (m *VarRef) String() string { return proto.CompactText...
method ProtoMessage (line 485) | func (*VarRef) ProtoMessage() {}
method Descriptor (line 486) | func (*VarRef) Descriptor() ([]byte, []int) { return fileDescriptorInt...
method GetVal (line 488) | func (m *VarRef) GetVal() string {
method GetType (line 495) | func (m *VarRef) GetType() int32 {
function init (line 502) | func init() {
function init (line 513) | func init() { proto.RegisterFile("internal/internal.proto", fileDescript...
FILE: vendor/github.com/influxdata/influxdb/influxql/iterator.gen.go
constant DefaultStatsInterval (line 23) | DefaultStatsInterval = 10 * time.Second
type FloatIterator (line 26) | type FloatIterator interface
function newFloatIterators (line 34) | func newFloatIterators(itrs []Iterator) []FloatIterator {
type bufFloatIterator (line 52) | type bufFloatIterator struct
method Stats (line 63) | func (itr *bufFloatIterator) Stats() IteratorStats { return itr.itr.St...
method Close (line 66) | func (itr *bufFloatIterator) Close() error { return itr.itr.Close() }
method peek (line 69) | func (itr *bufFloatIterator) peek() (*FloatPoint, error) {
method peekTime (line 80) | func (itr *bufFloatIterator) peekTime() (int64, error) {
method Next (line 89) | func (itr *bufFloatIterator) Next() (*FloatPoint, error) {
method NextInWindow (line 100) | func (itr *bufFloatIterator) NextInWindow(startTime, endTime int64) (*...
method unread (line 112) | func (itr *bufFloatIterator) unread(v *FloatPoint) { itr.buf = v }
function newBufFloatIterator (line 58) | func newBufFloatIterator(itr FloatIterator) *bufFloatIterator {
type floatMergeIterator (line 115) | type floatMergeIterator struct
method Stats (line 153) | func (itr *floatMergeIterator) Stats() IteratorStats {
method Close (line 162) | func (itr *floatMergeIterator) Close() error {
method Next (line 173) | func (itr *floatMergeIterator) Next() (*FloatPoint, error) {
function newFloatMergeIterator (line 131) | func newFloatMergeIterator(inputs []FloatIterator, opt IteratorOptions) ...
type floatMergeHeap (line 251) | type floatMergeHeap struct
method Len (line 256) | func (h *floatMergeHeap) Len() int { return len(h.items) }
method Swap (line 257) | func (h *floatMergeHeap) Swap(i, j int) { h.items[i], h.items[j] = h.i...
method Less (line 258) | func (h *floatMergeHeap) Less(i, j int) bool {
method Push (line 291) | func (h *floatMergeHeap) Push(x interface{}) {
method Pop (line 295) | func (h *floatMergeHeap) Pop() interface{} {
type floatMergeHeapItem (line 303) | type floatMergeHeapItem struct
type floatSortedMergeIterator (line 308) | type floatSortedMergeIterator struct
method Stats (line 334) | func (itr *floatSortedMergeIterator) Stats() IteratorStats {
method Close (line 343) | func (itr *floatSortedMergeIterator) Close() error {
method Next (line 351) | func (itr *floatSortedMergeIterator) Next() (*FloatPoint, error) { ret...
method pop (line 355) | func (itr *floatSortedMergeIterator) pop() (*FloatPoint, error) {
function newFloatSortedMergeIterator (line 315) | func newFloatSortedMergeIterator(inputs []FloatIterator, opt IteratorOpt...
type floatSortedMergeHeap (line 397) | type floatSortedMergeHeap struct
method Len (line 402) | func (h *floatSortedMergeHeap) Len() int { return len(h.items) }
method Swap (line 403) | func (h *floatSortedMergeHeap) Swap(i, j int) { h.items[i], h.items[j]...
method Less (line 404) | func (h *floatSortedMergeHeap) Less(i, j int) bool {
method Push (line 424) | func (h *floatSortedMergeHeap) Push(x interface{}) {
method Pop (line 428) | func (h *floatSortedMergeHeap) Pop() interface{} {
type floatSortedMergeHeapItem (line 436) | type floatSortedMergeHeapItem struct
type floatParallelIterator (line 443) | type floatParallelIterator struct
method Stats (line 465) | func (itr *floatParallelIterator) Stats() IteratorStats { return itr.i...
method Close (line 468) | func (itr *floatParallelIterator) Close() error {
method Next (line 475) | func (itr *floatParallelIterator) Next() (*FloatPoint, error) {
method monitor (line 484) | func (itr *floatParallelIterator) monitor() {
function newFloatParallelIterator (line 453) | func newFloatParallelIterator(input FloatIterator) *floatParallelIterator {
type floatPointError (line 503) | type floatPointError struct
type floatLimitIterator (line 509) | type floatLimitIterator struct
method Stats (line 529) | func (itr *floatLimitIterator) Stats() IteratorStats { return itr.inpu...
method Close (line 532) | func (itr *floatLimitIterator) Close() error { return itr.input.Close() }
method Next (line 535) | func (itr *floatLimitIterator) Next() (*FloatPoint, error) {
function newFloatLimitIterator (line 521) | func newFloatLimitIterator(input FloatIterator, opt IteratorOptions) *fl...
type floatFillIterator (line 566) | type floatFillIterator struct
method Stats (line 615) | func (itr *floatFillIterator) Stats() IteratorStats { return itr.input...
method Close (line 616) | func (itr *floatFillIterator) Close() error { return itr.input...
method Next (line 618) | func (itr *floatFillIterator) Next() (*FloatPoint, error) {
function newFloatFillIterator (line 583) | func newFloatFillIterator(input FloatIterator, expr Expr, opt IteratorOp...
type floatIntervalIterator (line 741) | type floatIntervalIterator struct
method Stats (line 750) | func (itr *floatIntervalIterator) Stats() IteratorStats { return itr.i...
method Close (line 751) | func (itr *floatIntervalIterator) Close() error { return itr.i...
method Next (line 753) | func (itr *floatIntervalIterator) Next() (*FloatPoint, error) {
function newFloatIntervalIterator (line 746) | func newFloatIntervalIterator(input FloatIterator, opt IteratorOptions) ...
type floatInterruptIterator (line 768) | type floatInterruptIterator struct
method Stats (line 778) | func (itr *floatInterruptIterator) Stats() IteratorStats { return itr....
method Close (line 779) | func (itr *floatInterruptIterator) Close() error { return itr....
method Next (line 781) | func (itr *floatInterruptIterator) Next() (*FloatPoint, error) {
function newFloatInterruptIterator (line 774) | func newFloatInterruptIterator(input FloatIterator, closing <-chan struc...
type floatCloseInterruptIterator (line 802) | type floatCloseInterruptIterator struct
method monitor (line 819) | func (itr *floatCloseInterruptIterator) monitor() {
method Stats (line 827) | func (itr *floatCloseInterruptIterator) Stats() IteratorStats {
method Close (line 831) | func (itr *floatCloseInterruptIterator) Close() error {
method Next (line 839) | func (itr *floatCloseInterruptIterator) Next() (*FloatPoint, error) {
function newFloatCloseInterruptIterator (line 809) | func newFloatCloseInterruptIterator(input FloatIterator, closing <-chan ...
type auxFloatPoint (line 854) | type auxFloatPoint struct
type floatAuxIterator (line 860) | type floatAuxIterator struct
method Background (line 875) | func (itr *floatAuxIterator) Background() {
method Start (line 881) | func (itr *floatAuxIterator) Start() { go itr.stream() }
method Stats (line 882) | func (itr *floatAuxIterator) Stats() IteratorStats { return itr.input....
method Close (line 883) | func (itr *floatAuxIterator) Close() error { return itr.input....
method Next (line 884) | func (itr *floatAuxIterator) Next() (*FloatPoint, error) {
method Iterator (line 888) | func (itr *floatAuxIterator) Iterator(name string, typ DataType) Itera...
method stream (line 892) | func (itr *floatAuxIterator) stream() {
function newFloatAuxIterator (line 867) | func newFloatAuxIterator(input FloatIterator, opt IteratorOptions) *floa...
type floatChanIterator (line 916) | type floatChanIterator struct
method Stats (line 927) | func (itr *floatChanIterator) Stats() IteratorStats { return IteratorS...
method Close (line 929) | func (itr *floatChanIterator) Close() error {
method setBuf (line 939) | func (itr *floatChanIterator) setBuf(name string, tags Tags, time int6...
method setErr (line 973) | func (itr *floatChanIterator) setErr(err error) {
method Next (line 982) | func (itr *floatChanIterator) Next() (*FloatPoint, error) {
type floatReduceFloatIterator (line 1013) | type floatReduceFloatIterator struct
method Stats (line 1032) | func (itr *floatReduceFloatIterator) Stats() IteratorStats { return it...
method Close (line 1035) | func (itr *floatReduceFloatIterator) Close() error { return itr.input....
method Next (line 1038) | func (itr *floatReduceFloatIterator) Next() (*FloatPoint, error) {
method reduce (line 1064) | func (itr *floatReduceFloatIterator) reduce() ([]FloatPoint, error) {
function newFloatReduceFloatIterator (line 1022) | func newFloatReduceFloatIterator(input FloatIterator, opt IteratorOption...
type floatReduceFloatPoint (line 1055) | type floatReduceFloatPoint struct
type floatStreamFloatIterator (line 1173) | type floatStreamFloatIterator struct
method Stats (line 1194) | func (itr *floatStreamFloatIterator) Stats() IteratorStats { return it...
method Close (line 1197) | func (itr *floatStreamFloatIterator) Close() error { return itr.input....
method Next (line 1200) | func (itr *floatStreamFloatIterator) Next() (*FloatPoint, error) {
method reduce (line 1218) | func (itr *floatStreamFloatIterator) reduce() ([]FloatPoint, error) {
function newFloatStreamFloatIterator (line 1183) | func newFloatStreamFloatIterator(input FloatIterator, createFn func() (F...
type floatExprIterator (line 1289) | type floatExprIterator struct
method Stats (line 1315) | func (itr *floatExprIterator) Stats() IteratorStats {
method Close (line 1321) | func (itr *floatExprIterator) Close() error {
method Next (line 1327) | func (itr *floatExprIterator) Next() (*FloatPoint, error) {
method next (line 1381) | func (itr *floatExprIterator) next() (a, b *FloatPoint, err error) {
function newFloatExprIterator (line 1297) | func newFloatExprIterator(left, right FloatIterator, opt IteratorOptions...
type floatExprFunc (line 1425) | type floatExprFunc
type floatReduceIntegerIterator (line 1428) | type floatReduceIntegerIterator struct
method Stats (line 1447) | func (itr *floatReduceIntegerIterator) Stats() IteratorStats { return ...
method Close (line 1450) | func (itr *floatReduceIntegerIterator) Close() error { return itr.inpu...
method Next (line 1453) | func (itr *floatReduceIntegerIterator) Next() (*IntegerPoint, error) {
method reduce (line 1479) | func (itr *floatReduceIntegerIterator) reduce() ([]IntegerPoint, error) {
function newFloatReduceIntegerIterator (line 1437) | func newFloatReduceIntegerIterator(input FloatIterator, opt IteratorOpti...
type floatReduceIntegerPoint (line 1470) | type floatReduceIntegerPoint struct
type floatStreamIntegerIterator (line 1588) | type floatStreamIntegerIterator struct
method Stats (line 1609) | func (itr *floatStreamIntegerIterator) Stats() IteratorStats { return ...
method Close (line 1612) | func (itr *floatStreamIntegerIterator) Close() error { return itr.inpu...
method Next (line 1615) | func (itr *floatStreamIntegerIterator) Next() (*IntegerPoint, error) {
method reduce (line 1633) | func (itr *floatStreamIntegerIterator) reduce() ([]IntegerPoint, error) {
function newFloatStreamIntegerIterator (line 1598) | func newFloatStreamIntegerIterator(input FloatIterator, createFn func() ...
type floatIntegerExprIterator (line 1704) | type floatIntegerExprIterator struct
method Stats (line 1730) | func (itr *floatIntegerExprIterator) Stats() IteratorStats {
method Close (line 1736) | func (itr *floatIntegerExprIterator) Close() error {
method Next (line 1742) | func (itr *floatIntegerExprIterator) Next() (*IntegerPoint, error) {
method next (line 1800) | func (itr *floatIntegerExprIterator) next() (a, b *FloatPoint, err err...
function newFloatIntegerExprIterator (line 1712) | func newFloatIntegerExprIterator(left, right FloatIterator, opt Iterator...
type floatIntegerExprFunc (line 1844) | type floatIntegerExprFunc
type floatReduceStringIterator (line 1847) | type floatReduceStringIterator struct
method Stats (line 1866) | func (itr *floatReduceStringIterator) Stats() IteratorStats { return i...
method Close (line 1869) | func (itr *floatReduceStringIterator) Close() error { return itr.input...
method Next (line 1872) | func (itr *floatReduceStringIterator) Next() (*StringPoint, error) {
method reduce (line 1898) | func (itr *floatReduceStringIterator) reduce() ([]StringPoint, error) {
function newFloatReduceStringIterator (line 1856) | func newFloatReduceStringIterator(input FloatIterator, opt IteratorOptio...
type floatReduceStringPoint (line 1889) | type floatReduceStringPoint struct
type floatStreamStringIterator (line 2007) | type floatStreamStringIterator struct
method Stats (line 2028) | func (itr *floatStreamStringIterator) Stats() IteratorStats { return i...
method Close (line 2031) | func (itr *floatStreamStringIterator) Close() error { return itr.input...
method Next (line 2034) | func (itr *floatStreamStringIterator) Next() (*StringPoint, error) {
method reduce (line 2052) | func (itr *floatStreamStringIterator) reduce() ([]StringPoint, error) {
function newFloatStreamStringIterator (line 2017) | func newFloatStreamStringIterator(input FloatIterator, createFn func() (...
type floatStringExprIterator (line 2123) | type floatStringExprIterator struct
method Stats (line 2149) | func (itr *floatStringExprIterator) Stats() IteratorStats {
method Close (line 2155) | func (itr *floatStringExprIterator) Close() error {
method Next (line 2161) | func (itr *floatStringExprIterator) Next() (*StringPoint, error) {
method next (line 2219) | func (itr *floatStringExprIterator) next() (a, b *FloatPoint, err erro...
function newFloatStringExprIterator (line 2131) | func newFloatStringExprIterator(left, right FloatIterator, opt IteratorO...
type floatStringExprFunc (line 2263) | type floatStringExprFunc
type floatReduceBooleanIterator (line 2266) | type floatReduceBooleanIterator struct
method Stats (line 2285) | func (itr *floatReduceBooleanIterator) Stats() IteratorStats { return ...
method Close (line 2288) | func (itr *floatReduceBooleanIterator) Close() error { return itr.inpu...
method Next (line 2291) | func (itr *floatReduceBooleanIterator) Next() (*BooleanPoint, error) {
method reduce (line 2317) | func (itr *floatReduceBooleanIterator) reduce() ([]BooleanPoint, error) {
function newFloatReduceBooleanIterator (line 2275) | func newFloatReduceBooleanIterator(input FloatIterator, opt IteratorOpti...
type floatReduceBooleanPoint (line 2308) | type floatReduceBooleanPoint struct
type floatStreamBooleanIterator (line 2426) | type floatStreamBooleanIterator struct
method Stats (line 2447) | func (itr *floatStreamBooleanIterator) Stats() IteratorStats { return ...
method Close (line 2450) | func (itr *floatStreamBooleanIterator) Close() error { return itr.inpu...
method Next (line 2453) | func (itr *floatStreamBooleanIterator) Next() (*BooleanPoint, error) {
method reduce (line 2471) | func (itr *floatStreamBooleanIterator) reduce() ([]BooleanPoint, error) {
function newFloatStreamBooleanIterator (line 2436) | func newFloatStreamBooleanIterator(input FloatIterator, createFn func() ...
type floatBooleanExprIterator (line 2542) | type floatBooleanExprIterator struct
method Stats (line 2568) | func (itr *floatBooleanExprIterator) Stats() IteratorStats {
method Close (line 2574) | func (itr *floatBooleanExprIterator) Close() error {
method Next (line 2580) | func (itr *floatBooleanExprIterator) Next() (*BooleanPoint, error) {
method next (line 2638) | func (itr *floatBooleanExprIterator) next() (a, b *FloatPoint, err err...
function newFloatBooleanExprIterator (line 2550) | func newFloatBooleanExprIterator(left, right FloatIterator, opt Iterator...
type floatBooleanExprFunc (line 2682) | type floatBooleanExprFunc
type floatTransformIterator (line 2686) | type floatTransformIterator struct
method Stats (line 2692) | func (itr *floatTransformIterator) Stats() IteratorStats { return itr....
method Close (line 2695) | func (itr *floatTransformIterator) Close() error { return itr.input.Cl...
method Next (line 2698) | func (itr *floatTransformIterator) Next() (*FloatPoint, error) {
type floatTransformFunc (line 2711) | type floatTransformFunc
type floatBoolTransformIterator (line 2715) | type floatBoolTransformIterator struct
method Stats (line 2721) | func (itr *floatBoolTransformIterator) Stats() IteratorStats { return ...
method Close (line 2724) | func (itr *floatBoolTransformIterator) Close() error { return itr.inpu...
method Next (line 2727) | func (itr *floatBoolTransformIterator) Next() (*BooleanPoint, error) {
type floatBoolTransformFunc (line 2740) | type floatBoolTransformFunc
type floatDedupeIterator (line 2746) | type floatDedupeIterator struct
method Stats (line 2883) | func (itr *floatDedupeIterator) Stats() IteratorStats { return itr.inp...
method Close (line 2886) | func (itr *floatDedupeIterator) Close() error { return itr.input.Close...
method Next (line 2889) | func (itr *floatDedupeIterator) Next() (*FloatPoint, error) {
type floatIteratorMapper (line 2751) | type floatIteratorMapper struct
method Next (line 2773) | func (itr *floatIteratorMapper) Next() (*FloatPoint, error) {
method Stats (line 2803) | func (itr *floatIteratorMapper) Stats() IteratorStats {
method Close (line 2811) | func (itr *floatIteratorMapper) Close() error {
function newFloatIteratorMapper (line 2759) | func newFloatIteratorMapper(itrs []Iterator, driver IteratorMap, fields ...
type floatFilterIterator (line 2815) | type floatFilterIterator struct
method Stats (line 2850) | func (itr *floatFilterIterator) Stats() IteratorStats { return itr.inp...
method Close (line 2851) | func (itr *floatFilterIterator) Close() error { return itr.inp...
method Next (line 2853) | func (itr *floatFilterIterator) Next() (*FloatPoint, error) {
function newFloatFilterIterator (line 2822) | func newFloatFilterIterator(input FloatIterator, cond Expr, opt Iterator...
function newFloatDedupeIterator (line 2875) | func newFloatDedupeIterator(input FloatIterator) *floatDedupeIterator {
type floatReaderIterator (line 2915) | type floatReaderIterator struct
method Stats (line 2932) | func (itr *floatReaderIterator) Stats() IteratorStats { return itr.dec...
method Close (line 2935) | func (itr *floatReaderIterator) Close() error {
method Next (line 2943) | func (itr *floatReaderIterator) Next() (*FloatPoint, error) {
function newFloatReaderIterator (line 2921) | func newFloatReaderIterator(r io.Reader, stats IteratorStats) *floatRead...
type IntegerIterator (line 2957) | type IntegerIterator interface
function newIntegerIterators (line 2965) | func newIntegerIterators(itrs []Iterator) []IntegerIterator {
type bufIntegerIterator (line 2980) | type bufIntegerIterator struct
method Stats (line 2991) | func (itr *bufIntegerIterator) Stats() IteratorStats { return itr.itr....
method Close (line 2994) | func (itr *bufIntegerIterator) Close() error { return itr.itr.Close() }
method peek (line 2997) | func (itr *bufIntegerIterator) peek() (*IntegerPoint, error) {
method peekTime (line 3008) | func (itr *bufIntegerIterator) peekTime() (int64, error) {
method Next (line 3017) | func (itr *bufIntegerIterator) Next() (*IntegerPoint, error) {
method NextInWindow (line 3028) | func (itr *bufIntegerIterator) NextInWindow(startTime, endTime int64) ...
method unread (line 3040) | func (itr *bufIntegerIterator) unread(v *IntegerPoint) { itr.buf = v }
function newBufIntegerIterator (line 2986) | func newBufIntegerIterator(itr IntegerIterator) *bufIntegerIterator {
type integerMergeIterator (line 3043) | type integerMergeIterator struct
method Stats (line 3081) | func (itr *integerMergeIterator) Stats() IteratorStats {
method Close (line 3090) | func (itr *integerMergeIterator) Close() error {
method Next (line 3101) | func (itr *integerMergeIterator) Next() (*IntegerPoint, error) {
function newIntegerMergeIterator (line 3059) | func newIntegerMergeIterator(inputs []IntegerIterator, opt IteratorOptio...
type integerMergeHeap (line 3179) | type integerMergeHeap struct
method Len (line 3184) | func (h *integerMergeHeap) Len() int { return len(h.items) }
method Swap (line 3185) | func (h *integerMergeHeap) Swap(i, j int) { h.items[i], h.items[j] = h...
method Less (line 3186) | func (h *integerMergeHeap) Less(i, j int) bool {
method Push (line 3219) | func (h *integerMergeHeap) Push(x interface{}) {
method Pop (line 3223) | func (h *integerMergeHeap) Pop() interface{} {
type integerMergeHeapItem (line 3231) | type integerMergeHeapItem struct
type integerSortedMergeIterator (line 3236) | type integerSortedMergeIterator struct
method Stats (line 3262) | func (itr *integerSortedMergeIterator) Stats() IteratorStats {
method Close (line 3271) | func (itr *integerSortedMergeIterator) Close() error {
method Next (line 3279) | func (itr *integerSortedMergeIterator) Next() (*IntegerPoint, error) {...
method pop (line 3283) | func (itr *integerSortedMergeIterator) pop() (*IntegerPoint, error) {
function newIntegerSortedMergeIterator (line 3243) | func newIntegerSortedMergeIterator(inputs []IntegerIterator, opt Iterato...
type integerSortedMergeHeap (line 3325) | type integerSortedMergeHeap struct
method Len (line 3330) | func (h *integerSortedMergeHeap) Len() int { return len(h.items) }
method Swap (line 3331) | func (h *integerSortedMergeHeap) Swap(i, j int) { h.items[i], h.items[...
method Less (line 3332) | func (h *integerSortedMergeHeap) Less(i, j int) bool {
method Push (line 3352) | func (h *integerSortedMergeHeap) Push(x interface{}) {
method Pop (line 3356) | func (h *integerSortedMergeHeap) Pop() interface{} {
type integerSortedMergeHeapItem (line 3364) | type integerSortedMergeHeapItem struct
type integerParallelIterator (line 3371) | type integerParallelIterator struct
method Stats (line 3393) | func (itr *integerParallelIterator) Stats() IteratorStats { return itr...
method Close (line 3396) | func (itr *integerParallelIterator)
Copy disabled (too large)
Download .json
Condensed preview — 1565 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (14,692K chars).
[
{
"path": ".gitignore",
"chars": 268,
"preview": "### Basic ignore file\n\n# Binaries for programs and plugins\nvsphere-influxdb\n\n# Test binary, build with `go test -c`\n*.te"
},
{
"path": ".travis.yml",
"chars": 536,
"preview": "language: go\nsudo: required\ngo:\n - 1.9\nenv:\n - PATH=/home/travis/gopath/bin:$PATH\nbefore_install:\n - sudo apt-get -qq"
},
{
"path": "Dockerfile",
"chars": 474,
"preview": "FROM golang:1.12-alpine3.10 as builder\n\nWORKDIR /go/src/vsphere-influxdb-go\nCOPY . .\nRUN apk --update add --virtual buil"
},
{
"path": "Gopkg.toml",
"chars": 825,
"preview": "\n# Gopkg.toml example\n#\n# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md\n# for detailed Gopkg.tom"
},
{
"path": "LICENSE.txt",
"chars": 35147,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "README.md",
"chars": 5590,
"preview": "[](https://github.co"
},
{
"path": "goreleaser.yml",
"chars": 1047,
"preview": "project_name: vsphere-influxdb-go\nbuilds:\n - binary: vsphere-influxdb-go\n goos:\n - windows\n - darwin\n "
},
{
"path": "tools/README.md",
"chars": 191,
"preview": "# Change vCenter metric collection level\n\n```\ngit clone https://github.com/Oxalide/vsphere-influxdb-go.git\npip install -"
},
{
"path": "tools/change_metric_collection_level.py",
"chars": 3690,
"preview": "#!/usr/bin/python\n#============================================\n# Script: change_metric_collection_level.py \n# Descripti"
},
{
"path": "tools/requirements.txt",
"chars": 26,
"preview": "pyVmomi\nrequests\nargparse\n"
},
{
"path": "vendor/github.com/davecgh/go-spew/.gitignore",
"chars": 252,
"preview": "# Compiled Object files, Static and Dynamic libs (Shared Objects)\n*.o\n*.a\n*.so\n\n# Folders\n_obj\n_test\n\n# Architecture spe"
},
{
"path": "vendor/github.com/davecgh/go-spew/.travis.yml",
"chars": 389,
"preview": "language: go\ngo:\n - 1.5.4\n - 1.6.3\n - 1.7\ninstall:\n - go get -v golang.org/x/tools/cmd/cover\nscript:\n - g"
},
{
"path": "vendor/github.com/davecgh/go-spew/LICENSE",
"chars": 763,
"preview": "ISC License\n\nCopyright (c) 2012-2016 Dave Collins <dave@davec.name>\n\nPermission to use, copy, modify, and distribute thi"
},
{
"path": "vendor/github.com/davecgh/go-spew/README.md",
"chars": 7125,
"preview": "go-spew\n=======\n\n[]\n(https://travis-ci.org/davecgh/go-"
},
{
"path": "vendor/github.com/davecgh/go-spew/cov_report.sh",
"chars": 658,
"preview": "#!/bin/sh\n\n# This script uses gocov to generate a test coverage report.\n# The gocov tool my be obtained with the followi"
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/bypass.go",
"chars": 5789,
"preview": "// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>\n//\n// Permission to use, copy, modify, and distribute this sof"
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/bypasssafe.go",
"chars": 1734,
"preview": "// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>\n//\n// Permission to use, copy, modify, and distribute this sof"
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/common.go",
"chars": 10364,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/common_test.go",
"chars": 7930,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/config.go",
"chars": 12842,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/doc.go",
"chars": 8527,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/dump.go",
"chars": 13813,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/dump_test.go",
"chars": 33788,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/dumpcgo_test.go",
"chars": 3872,
"preview": "// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n//\n// Permission to use, copy, modify, and distribute this sof"
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/dumpnocgo_test.go",
"chars": 1219,
"preview": "// Copyright (c) 2013 Dave Collins <dave@davec.name>\n//\n// Permission to use, copy, modify, and distribute this software"
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/example_test.go",
"chars": 5580,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/format.go",
"chars": 11330,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/format_test.go",
"chars": 57536,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/internal_test.go",
"chars": 2575,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/internalunsafe_test.go",
"chars": 3321,
"preview": "// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n\n// Permission to use, copy, modify, and distribute this softw"
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/spew.go",
"chars": 5969,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/spew_test.go",
"chars": 9641,
"preview": "/*\n * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>\n *\n * Permission to use, copy, modify, and distribute this "
},
{
"path": "vendor/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go",
"chars": 3284,
"preview": "// Copyright (c) 2013 Dave Collins <dave@davec.name>\n//\n// Permission to use, copy, modify, and distribute this software"
},
{
"path": "vendor/github.com/davecgh/go-spew/test_coverage.txt",
"chars": 4414,
"preview": "\ngithub.com/davecgh/go-spew/spew/dump.go\t\t dumpState.dump\t\t\t 100.00% (88/88)\ngithub.com/davecgh/go-spew/spew/format.go\t "
},
{
"path": "vendor/github.com/influxdata/influxdb/.dockerignore",
"chars": 6,
"preview": "build\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/.github/ISSUE_TEMPLATE.md",
"chars": 2212,
"preview": "### Directions\n_GitHub Issues are reserved for actionable bug reports and feature requests._\n_General questions should b"
},
{
"path": "vendor/github.com/influxdata/influxdb/.github/PULL_REQUEST_TEMPLATE.md",
"chars": 821,
"preview": "###### Required for all non-trivial PRs\n- [ ] Rebased/mergable\n- [ ] Tests pass\n- [ ] CHANGELOG.md updated\n- [ ] Sign [C"
},
{
"path": "vendor/github.com/influxdata/influxdb/.gitignore",
"chars": 871,
"preview": "# Keep editor-specific, non-project specific ignore rules in global .gitignore:\n# https://help.github.com/articles/ignor"
},
{
"path": "vendor/github.com/influxdata/influxdb/.hooks/pre-commit",
"chars": 754,
"preview": "#!/usr/bin/env bash\n\nfmtcount=`git ls-files | grep '.go$' | xargs gofmt -l 2>&1 | wc -l`\nif [ $fmtcount -gt 0 ]; then\n "
},
{
"path": "vendor/github.com/influxdata/influxdb/.mention-bot",
"chars": 166,
"preview": "{\n \"maxReviewers\": 3,\n \"fileBlacklist\": [\"CHANGELOG.md\"],\n \"userBlacklist\": [\"pauldix\", \"toddboom\", \"aviau\", \"mark-ru"
},
{
"path": "vendor/github.com/influxdata/influxdb/CHANGELOG.md",
"chars": 205745,
"preview": "## v1.3.6 [unreleased]\n\n### Bugfixes\n\n- [#8770](https://github.com/influxdata/influxdb/pull/8770): Reduce how long it ta"
},
{
"path": "vendor/github.com/influxdata/influxdb/CODING_GUIDELINES.md",
"chars": 3830,
"preview": "_This document is currently in draft form._\n\n# Background\n\nThe goal of this guide is to capture some Do and Don'ts of Go"
},
{
"path": "vendor/github.com/influxdata/influxdb/CONTRIBUTING.md",
"chars": 11285,
"preview": "Contributing to InfluxDB\n========================\n\nBug reports\n---------------\nBefore you file an issue, please search e"
},
{
"path": "vendor/github.com/influxdata/influxdb/Dockerfile_build_ubuntu32",
"chars": 851,
"preview": "FROM ioft/i386-ubuntu:14.04\n\nRUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \\\n python-softwa"
},
{
"path": "vendor/github.com/influxdata/influxdb/Dockerfile_build_ubuntu64",
"chars": 889,
"preview": "FROM ubuntu:trusty\n\nRUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \\\n python-software-proper"
},
{
"path": "vendor/github.com/influxdata/influxdb/Dockerfile_build_ubuntu64_git",
"chars": 979,
"preview": "FROM ubuntu:trusty\n\nRUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \\\n python-software-proper"
},
{
"path": "vendor/github.com/influxdata/influxdb/Dockerfile_test_ubuntu32",
"chars": 502,
"preview": "FROM 32bit/ubuntu:14.04\n\nRUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y python-software-propert"
},
{
"path": "vendor/github.com/influxdata/influxdb/Godeps",
"chars": 1412,
"preview": "collectd.org e84e8af5356e7f47485bbc95c96da6dd7984a67e\ngithub.com/BurntSushi/toml 99064174e013895bbd9b025c31100bd1d9b590c"
},
{
"path": "vendor/github.com/influxdata/influxdb/LICENSE",
"chars": 1085,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2013-2016 Errplane Inc.\n\nPermission is hereby granted, free of charge, to any perso"
},
{
"path": "vendor/github.com/influxdata/influxdb/LICENSE_OF_DEPENDENCIES.md",
"chars": 2379,
"preview": "# List\n- bootstrap 3.3.5 [MIT LICENSE](https://github.com/twbs/bootstrap/blob/master/LICENSE)\n- collectd.org [ISC LICENS"
},
{
"path": "vendor/github.com/influxdata/influxdb/Makefile",
"chars": 870,
"preview": "PACKAGES=$(shell find . -name '*.go' -print0 | xargs -0 -n1 dirname | sort --unique)\n\ndefault:\n\nmetalint: deadcode cyclo"
},
{
"path": "vendor/github.com/influxdata/influxdb/QUERIES.md",
"chars": 5242,
"preview": "The top level name is called a measurement. These names can contain any characters. Then there are field names, field va"
},
{
"path": "vendor/github.com/influxdata/influxdb/README.md",
"chars": 3642,
"preview": "# InfluxDB [](https://circleci.com/gh"
},
{
"path": "vendor/github.com/influxdata/influxdb/TODO.md",
"chars": 467,
"preview": "# TODO\n\n## v2\n\nTODO list for v2. Here is a list of things we want to add to v1, but can't because they would be a breaki"
},
{
"path": "vendor/github.com/influxdata/influxdb/appveyor.yml",
"chars": 842,
"preview": "version: 0.{build}\r\npull_requests:\r\n do_not_increment_build_number: true\r\nbranches:\r\n only:\r\n - master\r\n\r\nos: Windows"
},
{
"path": "vendor/github.com/influxdata/influxdb/build.py",
"chars": 41563,
"preview": "#!/usr/bin/python2.7 -u\n\nimport sys\nimport os\nimport subprocess\nimport time\nfrom datetime import datetime\nimport shutil\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/build.sh",
"chars": 548,
"preview": "#!/bin/bash\n# Run the build utility via Docker\n\nset -e\n\n# Make sure our working dir is the dir of the script\nDIR=$(cd $("
},
{
"path": "vendor/github.com/influxdata/influxdb/circle-test.sh",
"chars": 1057,
"preview": "#!/bin/bash\n#\n# This is the InfluxDB test script for CircleCI, it is a light wrapper around ./test.sh.\n\n# Exit if any co"
},
{
"path": "vendor/github.com/influxdata/influxdb/circle.yml",
"chars": 1149,
"preview": "machine:\n services:\n - docker\n environment:\n GODIST: \"go1.8.3.linux-amd64.tar.gz\"\n post:\n - mk"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/README.md",
"chars": 7803,
"preview": "# InfluxDB Client\n\n[](http://godoc.org/github.com/i"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/example_test.go",
"chars": 2434,
"preview": "package client_test\n\nimport (\n\t\"fmt\"\n\t\"log\"\n\t\"math/rand\"\n\t\"net/url\"\n\t\"os\"\n\t\"strconv\"\n\t\"time\"\n\n\t\"github.com/influxdata/in"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/influxdb.go",
"chars": 21741,
"preview": "// Package client implements a now-deprecated client for InfluxDB;\n// use github.com/influxdata/influxdb/client/v2 inste"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/influxdb_test.go",
"chars": 24188,
"preview": "package client_test\n\nimport (\n\t\"crypto/tls\"\n\t\"encoding/json\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io/ioutil\"\n\t\"net/http\"\n\t\"net/http/httpte"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/v2/client.go",
"chars": 15421,
"preview": "// Package client (v2) is the current official Go client for InfluxDB.\npackage client // import \"github.com/influxdata/i"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/v2/client_test.go",
"chars": 14062,
"preview": "package client\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n\t\"reflect\"\n\t\"strings\"\n\t\"sync\"\n\t\"testin"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/v2/example_test.go",
"chars": 6117,
"preview": "package client_test\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n\t\"os\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/client/v2\"\n)\n\n// Creat"
},
{
"path": "vendor/github.com/influxdata/influxdb/client/v2/udp.go",
"chars": 2488,
"preview": "package client\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"time\"\n)\n\nconst (\n\t// UDPPayloadSize is a reasonable default payload size "
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx/cli/cli.go",
"chars": 32767,
"preview": "// Package cli contains the logic of the influx command line client.\npackage cli // import \"github.com/influxdata/influx"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx/cli/cli_internal_test.go",
"chars": 1298,
"preview": "package cli\n\nimport \"testing\"\n\nfunc TestParseCommand_InsertInto(t *testing.T) {\n\tt.Parallel()\n\n\tc := CommandLine{}\n\n\ttes"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx/cli/cli_test.go",
"chars": 14206,
"preview": "package cli_test\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"net\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n\t\"net/url\"\n\t\"strconv\"\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx/cli/parser.go",
"chars": 610,
"preview": "package cli\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n)\n\nfunc parseDatabaseAndRetentionPolicy(stmt []byte) (string, string, error) {\n\tva"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx/cli/parser_internal_test.go",
"chars": 1459,
"preview": "package cli\n\nimport (\n\t\"errors\"\n\t\"testing\"\n)\n\nfunc Test_parseDatabaseAndretentionPolicy(t *testing.T) {\n\ttests := []stru"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx/main.go",
"chars": 4686,
"preview": "// The influx command is a CLI client to InfluxDB.\npackage main\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/influxdata/"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_stress/README.md",
"chars": 1494,
"preview": "# `influx_stress`\n\nIf you run into any issues with this tool please mention @jackzampolin when you create an issue.\n\n## "
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_stress/examples/template.toml",
"chars": 3245,
"preview": "# This section can be removed\n[provision]\n # The basic provisioner simply deletes and creates database.\n # If `reset_d"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_stress/influx_stress.go",
"chars": 1702,
"preview": "// Command influx_stress is deprecated; use github.com/influxdata/influx-stress instead.\npackage main\n\nimport (\n\t\"flag\"\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/README.md",
"chars": 7746,
"preview": "# Converting b1 and bz1 shards to tsm1\n\n`influx_tsm` is a tool for converting b1 and bz1 shards to tsm1\nformat. Converti"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/b1/reader.go",
"chars": 6025,
"preview": "// Package b1 reads data from b1 shards.\npackage b1 // import \"github.com/influxdata/influxdb/cmd/influx_tsm/b1\"\n\nimport"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/bz1/reader.go",
"chars": 8612,
"preview": "// Package bz1 reads data from bz1 shards.\npackage bz1 // import \"github.com/influxdata/influxdb/cmd/influx_tsm/bz1\"\n\nim"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/converter.go",
"chars": 2509,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\n\t\"github.com/influxdata/influxdb/cmd/influx_tsm/stats\"\n\t\"github.co"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/main.go",
"chars": 10992,
"preview": "// Command influx_tsm converts b1 or bz1 shards (from InfluxDB releases earlier than v0.11)\n// to the current tsm1 forma"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/stats/stats.go",
"chars": 1400,
"preview": "// Package stats contains statistics for converting non-TSM shards to TSM.\npackage stats\n\nimport (\n\t\"sync/atomic\"\n\t\"time"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tracker.go",
"chars": 3709,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"log\"\n\t\"runtime\"\n\t\"sync\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/cmd/inf"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/codec.go",
"chars": 3304,
"preview": "package tsdb\n\nimport (\n\t\"encoding/binary\"\n\t\"errors\"\n\t\"fmt\"\n\t\"math\"\n)\n\nconst (\n\tfieldFloat = 1\n\tfieldInteger = 2\n\tfield"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/database.go",
"chars": 5320,
"preview": "// Pacage tsdb abstracts the various shard types supported by the influx_tsm command.\npackage tsdb // import \"github.com"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/internal/meta.pb.go",
"chars": 2867,
"preview": "// Code generated by protoc-gen-gogo.\n// source: internal/meta.proto\n// DO NOT EDIT!\n\n/*\nPackage internal is a generated"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/types.go",
"chars": 1593,
"preview": "package tsdb\n\nimport (\n\t\"encoding/binary\"\n\t\"strings\"\n\n\t\"github.com/influxdata/influxdb/cmd/influx_tsm/tsdb/internal\"\n\t\"g"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/backup/backup.go",
"chars": 10793,
"preview": "// Package backup is the backup subcommand for the influxd command.\npackage backup\n\nimport (\n\t\"encoding/binary\"\n\t\"encodi"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/help/help.go",
"chars": 1089,
"preview": "// Package help is the help subcommand of the influxd command.\npackage help\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"strings\"\n)\n\n/"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/main.go",
"chars": 4089,
"preview": "// Command influxd is the InfluxDB server.\npackage main\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"io\"\n\t\"math/rand\"\n\t\"os\"\n\t\"os/signal\"\n\t"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/restore/restore.go",
"chars": 9431,
"preview": "// Package restore is the restore subcommand for the influxd command,\n// for restoring from a backup.\npackage restore\n\ni"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/run/command.go",
"chars": 6892,
"preview": "// Package run is the run (default) subcommand for the influxd command.\npackage run\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"io\"\n\t\"io/"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/run/config.go",
"chars": 10793,
"preview": "package run\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io/ioutil\"\n\t\"log\"\n\t\"os\"\n\t\"os/user\"\n\t\"path/filepath\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"strco"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/run/config_command.go",
"chars": 2411,
"preview": "package run\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\n\t\"github.com/BurntSushi/toml\"\n)\n\n// PrintConfigCommand represents the "
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/run/config_test.go",
"chars": 7690,
"preview": "package run_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"testing\"\n\n\t\"github.com/BurntSushi/toml\"\n\t\"github.com/influxdata/influxdb/cmd/i"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/influxd/run/server.go",
"chars": 16538,
"preview": "package run\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"runtime\"\n\t\"runtime/pprof\"\n\t\"time\"\n\n\t\"github.co"
},
{
"path": "vendor/github.com/influxdata/influxdb/cmd/parse.go",
"chars": 868,
"preview": "// Package cmd is the root package of the various command-line utilities for InfluxDB.\npackage cmd\n\nimport \"strings\"\n\n//"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/config.go",
"chars": 2403,
"preview": "// Package coordinator contains abstractions for writing points, executing statements,\n// and accessing meta data.\npacka"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/config_test.go",
"chars": 461,
"preview": "package coordinator_test\n\nimport (\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/BurntSushi/toml\"\n\t\"github.com/influxdata/influxdb/co"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/meta_client.go",
"chars": 1655,
"preview": "package coordinator\n\nimport (\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n\t\"github.com/influxdata/influxdb/servi"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/meta_client_test.go",
"chars": 6318,
"preview": "package coordinator_test\n\nimport (\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n\t\"github.com/influxdata/influxdb/"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/points_writer.go",
"chars": 12431,
"preview": "package coordinator\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"sort\"\n\t\"sync\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb\""
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/points_writer_internal_test.go",
"chars": 1202,
"preview": "package coordinator\n\nimport (\n\t\"testing\"\n\t\"time\"\n)\n\nfunc TestSgList_ShardGroupAt(t *testing.T) {\n\tbase := time.Date(2016"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/points_writer_test.go",
"chars": 19603,
"preview": "package coordinator_test\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"sync\"\n\t\"sync/atomic\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/influxdata/"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/shard_mapper.go",
"chars": 4848,
"preview": "package coordinator\n\nimport (\n\t\"io\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n\t\"github.com/influxdata/influxdb"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/shard_mapper_test.go",
"chars": 2891,
"preview": "package coordinator_test\n\nimport (\n\t\"reflect\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/coordinator\"\n\t\"github"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/statement_executor.go",
"chars": 35890,
"preview": "package coordinator\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"sort\"\n\t\"strconv\"\n\t\"time\"\n\n\t\"github.com/influxdata/influx"
},
{
"path": "vendor/github.com/influxdata/influxdb/coordinator/statement_executor_test.go",
"chars": 14197,
"preview": "package coordinator_test\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"io\"\n\t\"os\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/"
},
{
"path": "vendor/github.com/influxdata/influxdb/errors.go",
"chars": 1155,
"preview": "package influxdb\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"strings\"\n)\n\n// ErrFieldTypeConflict is returned when a new field already e"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/.rvmrc",
"chars": 36,
"preview": "rvm use ruby-2.1.0@burn-in --create\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/Gemfile",
"chars": 61,
"preview": "source 'https://rubygems.org'\n\ngem \"colorize\"\ngem \"influxdb\"\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/Gemfile.lock",
"chars": 170,
"preview": "GEM\n remote: https://rubygems.org/\n specs:\n colorize (0.6.0)\n influxdb (0.0.16)\n json\n json (1.8.1)\n\nPLA"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/burn-in.rb",
"chars": 2123,
"preview": "require \"influxdb\"\nrequire \"colorize\"\nrequire \"benchmark\"\n\nrequire_relative \"log\"\nrequire_relative \"random_gaussian\"\n\nBA"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/log.rb",
"chars": 423,
"preview": "module Log\n def self.info(msg)\n print Time.now.strftime(\"%r\") + \" | \"\n puts msg.to_s.colorize(:yellow)\n end\n\n d"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/random_gaussian.rb",
"chars": 673,
"preview": "class RandomGaussian\n def initialize(mean, stddev, rand_helper = lambda { Kernel.rand })\n @rand_helper = rand_helper"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/burn-in/random_points.rb",
"chars": 614,
"preview": "require \"influxdb\"\n\nONE_WEEK_IN_SECONDS = 7*24*60*60\nNUM_POINTS = 10_000\nBATCHES = 100\n\nmaster = InfluxDB::Client.new\nma"
},
{
"path": "vendor/github.com/influxdata/influxdb/etc/config.sample.toml",
"chars": 14349,
"preview": "### Welcome to the InfluxDB configuration file.\n\n# The values in this file override the default values used by the syste"
},
{
"path": "vendor/github.com/influxdata/influxdb/gobuild.sh",
"chars": 442,
"preview": "#!/bin/bash\n# This script run inside the Dockerfile_build_ubuntu64_git container and\n# gets the latests Go source code a"
},
{
"path": "vendor/github.com/influxdata/influxdb/importer/README.md",
"chars": 6945,
"preview": "# Import/Export\n\n## Exporting from 0.8.9\n\nVersion `0.8.9` of InfluxDB adds support to export your data to a format that "
},
{
"path": "vendor/github.com/influxdata/influxdb/importer/v8/importer.go",
"chars": 6582,
"preview": "// Package v8 contains code for importing data from 0.8 instances of InfluxDB.\npackage v8 // import \"github.com/influxda"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxdb.go",
"chars": 303,
"preview": "// Package influxdb is the root package of InfluxDB,\n// the scalable datastore for metrics, events, and real-time analyt"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/README.md",
"chars": 32599,
"preview": "# The Influx Query Language Specification\n\n## Introduction\n\nThis is a reference for the Influx Query Language (\"InfluxQL"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/ast.go",
"chars": 150011,
"preview": "package influxql\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"math\"\n\t\"regexp\"\n\t\"regexp/syntax\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n\t\""
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/ast_test.go",
"chars": 59942,
"preview": "package influxql_test\n\nimport (\n\t\"fmt\"\n\t\"go/importer\"\n\t\"reflect\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/influxdata/"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/call_iterator.go",
"chars": 36495,
"preview": "package influxql\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"sort\"\n\t\"time\"\n)\n\n/*\nThis file contains iterator implementations for each fun"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/call_iterator_test.go",
"chars": 42512,
"preview": "package influxql_test\n\nimport (\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/davecgh/go-spew/spew\"\n\t\"github.com/influxdata/influxdb/"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/cast.go",
"chars": 573,
"preview": "package influxql\n\nfunc castToFloat(v interface{}) float64 {\n\tswitch v := v.(type) {\n\tcase float64:\n\t\treturn v\n\tcase int6"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/doc.go",
"chars": 380,
"preview": "/*\nPackage influxql implements a parser for the InfluxDB query language.\n\nInfluxQL is a DML and DDL language for the Inf"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/emitter.go",
"chars": 5447,
"preview": "package influxql\n\nimport (\n\t\"fmt\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/models\"\n)\n\n// Emitter groups values together"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/emitter_test.go",
"chars": 3819,
"preview": "package influxql_test\n\nimport (\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/davecgh/go-spew/spew\"\n\t\"github.com/influxdata/influxdb/"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/functions.gen.go",
"chars": 58422,
"preview": "// Generated by tmpl\n// https://github.com/benbjohnson/tmpl\n//\n// DO NOT EDIT!\n// Source: functions.gen.go.tmpl\n\npackage"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/functions.gen.go.tmpl",
"chars": 8364,
"preview": "package influxql\n\nimport (\n\"sort\"\n\"time\"\n\"math/rand\"\n)\n\n{{with $types := .}}{{range $k := $types}}\n\n// {{$k.Name}}PointA"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/functions.go",
"chars": 31569,
"preview": "package influxql\n\nimport (\n\t\"container/heap\"\n\t\"math\"\n\t\"sort\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/influxql/nelderme"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/functions_test.go",
"chars": 15477,
"preview": "package influxql_test\n\nimport (\n\t\"math\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/davecgh/go-spew/spew\"\n\t\"github.com/influxdata/i"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/influxql.go",
"chars": 295,
"preview": "package influxql // import \"github.com/influxdata/influxdb/influxql\"\n\n//go:generate tmpl -data=@tmpldata iterator.gen.go"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/internal/internal.pb.go",
"chars": 19136,
"preview": "// Code generated by protoc-gen-gogo.\n// source: internal/internal.proto\n// DO NOT EDIT!\n\n/*\nPackage influxql is a gener"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/internal/internal.proto",
"chars": 2126,
"preview": "syntax = \"proto2\";\npackage influxql;\n\nmessage Point {\n required string Name = 1;\n required string Tags "
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/iterator.gen.go",
"chars": 317271,
"preview": "// Generated by tmpl\n// https://github.com/benbjohnson/tmpl\n//\n// DO NOT EDIT!\n// Source: iterator.gen.go.tmpl\n\npackage "
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/iterator.gen.go.tmpl",
"chars": 50260,
"preview": "package influxql\n\nimport (\n\t\"container/heap\"\n\t\"encoding/binary\"\n\t\"fmt\"\n\t\"io\"\n\t\"sort\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/gogo/"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/iterator.go",
"chars": 39217,
"preview": "package influxql\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/models\"\n\n\t\"github.co"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/iterator_mapper.go",
"chars": 1344,
"preview": "package influxql\n\nimport \"fmt\"\n\ntype IteratorMap interface {\n\tValue(tags Tags, buf []interface{}) interface{}\n}\n\ntype Fi"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/iterator_mapper_test.go",
"chars": 2169,
"preview": "package influxql_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/davecgh/go-spew/spew\"\n\t\"github.com/influxdata/influxdb/influxql"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/iterator_test.go",
"chars": 50527,
"preview": "package influxql_test\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"math\"\n\t\"reflect\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/davecgh/go-spew/spew"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/linear.go",
"chars": 1137,
"preview": "package influxql\n\n// linearFloat computes the the slope of the line between the points (previousTime, previousValue) and"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/monitor.go",
"chars": 556,
"preview": "package influxql\n\nimport \"time\"\n\n// PointLimitMonitor is a query monitor that exits when the number of points\n// emitted"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/neldermead/neldermead.go",
"chars": 4931,
"preview": "// Package neldermead is an implementation of the Nelder-Mead optimization method.\n// Based on work by Michael F. Hutt: "
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/neldermead/neldermead_test.go",
"chars": 1357,
"preview": "package neldermead_test\n\nimport (\n\t\"math\"\n\t\"testing\"\n\n\t\"github.com/influxdata/influxdb/influxql/neldermead\"\n)\n\nfunc roun"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/parser.go",
"chars": 79917,
"preview": "package influxql\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"regexp\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n)\n\nco"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/parser_test.go",
"chars": 128648,
"preview": "package influxql_test\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/point.gen.go",
"chars": 23332,
"preview": "// Generated by tmpl\n// https://github.com/benbjohnson/tmpl\n//\n// DO NOT EDIT!\n// Source: point.gen.go.tmpl\n\npackage inf"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/point.gen.go.tmpl",
"chars": 6671,
"preview": "package influxql\n\nimport (\n\t\"encoding/binary\"\n\t\"io\"\n\n\t\"github.com/gogo/protobuf/proto\"\n\tinternal \"github.com/influxdata/"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/point.go",
"chars": 7537,
"preview": "package influxql\n\nimport (\n\t\"bytes\"\n\t\"encoding/binary\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"sort\"\n\n\t\"github.com/gogo/protobuf/proto\"\n\t"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/point_test.go",
"chars": 5184,
"preview": "package influxql_test\n\nimport (\n\t\"reflect\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/davecgh/go-spew/spew\"\n\t\"github.com/influx"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/query_executor.go",
"chars": 13641,
"preview": "package influxql\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"runtime/debug\"\n\t\"sync\"\n\t\"sync/atomic\"\n\t\"time\"\n\n\t\"github.com/influxdata/inf"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/query_executor_test.go",
"chars": 9780,
"preview": "package influxql_test\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/influxq"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/result.go",
"chars": 3583,
"preview": "package influxql\n\nimport (\n\t\"encoding/json\"\n\t\"errors\"\n\t\"fmt\"\n\n\t\"github.com/influxdata/influxdb/models\"\n)\n\nconst (\n\t// Wa"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/sanitize.go",
"chars": 1355,
"preview": "package influxql\n\nimport (\n\t\"bytes\"\n\t\"regexp\"\n)\n\nvar (\n\tsanitizeSetPassword = regexp.MustCompile(`(?i)password\\s+for[^=]"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/sanitize_test.go",
"chars": 1135,
"preview": "package influxql_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n)\n\nfunc TestSanitize(t *testing.T"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/scanner.go",
"chars": 14846,
"preview": "package influxql\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n)\n\n// Scanner represents a lexical scanner for Influ"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/scanner_test.go",
"chars": 10244,
"preview": "package influxql_test\n\nimport (\n\t\"reflect\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n)\n\n// Ensur"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/select.go",
"chars": 37433,
"preview": "package influxql\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"math\"\n\t\"sort\"\n\t\"time\"\n)\n\n// SelectOptions are options that customize the s"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/select_test.go",
"chars": 179129,
"preview": "package influxql_test\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n\t\"reflect\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/davecgh/go-spew/spew\"\n\t\""
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/statement_rewriter.go",
"chars": 5916,
"preview": "package influxql\n\nimport \"errors\"\n\n// RewriteStatement rewrites stmt into a new statement, if applicable.\nfunc RewriteSt"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/statement_rewriter_test.go",
"chars": 4663,
"preview": "package influxql_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n)\n\nfunc TestRewriteStatement(t *t"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/subquery.go",
"chars": 3778,
"preview": "package influxql\n\ntype subqueryBuilder struct {\n\tic IteratorCreator\n\tstmt *SelectStatement\n}\n\n// buildAuxIterator cons"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/task_manager.go",
"chars": 6400,
"preview": "package influxql\n\nimport (\n\t\"fmt\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/models\"\n\t\"github.com/uber-go/zap\"\n)\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/tmpldata",
"chars": 393,
"preview": "[\n\t{\n\t\t\"Name\":\"Float\",\n\t\t\"name\":\"float\",\n\t\t\"Type\":\"float64\",\n\t\t\"Nil\":\"0\",\n\t\t\"Zero\":\"float64(0)\"\n\t},\n\t{\n\t\t\"Name\":\"Integer"
},
{
"path": "vendor/github.com/influxdata/influxdb/influxql/token.go",
"chars": 5908,
"preview": "package influxql\n\nimport (\n\t\"strings\"\n)\n\n// Token is a lexical token of the InfluxQL language.\ntype Token int\n\n// These "
},
{
"path": "vendor/github.com/influxdata/influxdb/internal/meta_client.go",
"chars": 6863,
"preview": "package internal\n\nimport (\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/influxql\"\n\t\"github.com/influxdata/influxdb/services"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/Makefile",
"chars": 870,
"preview": "#!/usr/bin/make -f\n\nDESTDIR = /usr/local\n\nMAN1_TXT =\nMAN1_TXT += influxd.txt\nMAN1_TXT += influxd-backup.txt\nMAN1_TXT += "
},
{
"path": "vendor/github.com/influxdata/influxdb/man/README.md",
"chars": 998,
"preview": "# Building the Man Pages\n\nThe man pages are created with `asciidoc`, `docbook`, and `xmlto`.\n\n## Debian/Ubuntu\n\nThis is "
},
{
"path": "vendor/github.com/influxdata/influxdb/man/footer.txt",
"chars": 338,
"preview": "BUGS\n----\nReport bugs to the GitHub issue tracker <https://github.com/influxdata/influxdb>.\n\nAUTHORS\n-------\nInfluxDB is"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influx.txt",
"chars": 2169,
"preview": "influx(1)\n=========\n\nNAME\n----\ninflux - InfluxDB client\n\nSYNOPSIS\n--------\n[verse]\n'influx' [options]\n'influx' -execute "
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influx_inspect.txt",
"chars": 1799,
"preview": "influx_inspect(1)\n=================\n\nNAME\n----\ninflux_inspect - Displays detailed information about InfluxDB data files\n"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influx_stress.txt",
"chars": 1544,
"preview": "influx_stress(1)\n================\n\nNAME\n----\ninflux_stress - Runs a stress test against one or multiple InfluxDB servers"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influx_tsm.txt",
"chars": 1484,
"preview": "influx_tsm(1)\n=============\n\nNAME\n----\ninflux_tsm - Convert a database from b1 or bz1 format to tsm1 format\n\nSYNPOSIS\n--"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influxd-backup.txt",
"chars": 790,
"preview": "influxd-backup(1)\n=================\n\nNAME\n----\ninfluxd-backup - Downloads a snapshot of a data node and saves it to disk"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influxd-config.txt",
"chars": 1888,
"preview": "influxd-config(1)\n=================\n\nNAME\n----\ninfluxd-config - Generate configuration files for InfluxDB\n\nSYNOPSIS\n----"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influxd-restore.txt",
"chars": 1020,
"preview": "influxd-restore(1)\n==================\n\nNAME\n----\ninfluxd-restore - Restores the metastore, databases, retention policies"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influxd-run.txt",
"chars": 941,
"preview": "influxd-run(1)\n==============\n\nNAME\n----\ninfluxd-run - Configure and start an InfluxDB server\n\nSYNOPSIS\n--------\n[verse]"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influxd-version.txt",
"chars": 258,
"preview": "influxd-version(1)\n==================\n\nNAME\n----\ninfluxd-version - Display the version of influxdb\n\nSYNOPSIS\n--------\n[v"
},
{
"path": "vendor/github.com/influxdata/influxdb/man/influxd.txt",
"chars": 1131,
"preview": "influxd(1)\n==========\n\nNAME\n----\ninfluxd - InfluxDB server daemon\n\nSYNOPSIS\n--------\n[verse]\n'influxd' [command] [option"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/consistency.go",
"chars": 1365,
"preview": "package models\n\nimport (\n\t\"errors\"\n\t\"strings\"\n)\n\n// ConsistencyLevel represent a required replication criteria before a "
},
{
"path": "vendor/github.com/influxdata/influxdb/models/inline_fnv.go",
"chars": 820,
"preview": "package models // import \"github.com/influxdata/influxdb/models\"\n\n// from stdlib hash/fnv/fnv.go\nconst (\n\tprime64 = 109"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/inline_fnv_test.go",
"chars": 506,
"preview": "package models_test\n\nimport (\n\t\"hash/fnv\"\n\t\"testing\"\n\t\"testing/quick\"\n\n\t\"github.com/influxdata/influxdb/models\"\n)\n\nfunc "
},
{
"path": "vendor/github.com/influxdata/influxdb/models/inline_strconv_parse.go",
"chars": 1097,
"preview": "package models // import \"github.com/influxdata/influxdb/models\"\n\nimport (\n\t\"reflect\"\n\t\"strconv\"\n\t\"unsafe\"\n)\n\n// parseIn"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/inline_strconv_parse_test.go",
"chars": 2290,
"preview": "package models\n\nimport (\n\t\"strconv\"\n\t\"testing\"\n\t\"testing/quick\"\n)\n\nfunc TestParseIntBytesEquivalenceFuzz(t *testing.T) {"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/points.go",
"chars": 55284,
"preview": "// Package models implements basic objects used throughout the TICK stack.\npackage models // import \"github.com/influxda"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/points_internal_test.go",
"chars": 455,
"preview": "package models\n\nimport \"testing\"\n\nfunc TestMarshalPointNoFields(t *testing.T) {\n\tpoints, err := ParsePointsString(\"m,k=v"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/points_test.go",
"chars": 62653,
"preview": "package models_test\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\t\"math/rand\"\n\t\"reflect\"\n\t\"strconv\"\n\t\"strings\"\n\t\"testing\"\n\t\"t"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/rows.go",
"chars": 1659,
"preview": "package models\n\nimport (\n\t\"sort\"\n)\n\n// Row represents a single row returned from the execution of a statement.\ntype Row "
},
{
"path": "vendor/github.com/influxdata/influxdb/models/statistic.go",
"chars": 1176,
"preview": "package models\n\n// Statistic is the representation of a statistic used by the monitoring service.\ntype Statistic struct "
},
{
"path": "vendor/github.com/influxdata/influxdb/models/statistic_test.go",
"chars": 1310,
"preview": "package models_test\n\nimport (\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/influxdata/influxdb/models\"\n)\n\nfunc TestTags_Merge(t *"
},
{
"path": "vendor/github.com/influxdata/influxdb/models/time.go",
"chars": 2363,
"preview": "package models\n\n// Helper time methods since parsing time can easily overflow and we only support a\n// specific time ran"
},
{
"path": "vendor/github.com/influxdata/influxdb/monitor/README.md",
"chars": 5048,
"preview": "# System Monitoring\n_This functionality should be considered experimental and is subject to change._\n\n_System Monitoring"
},
{
"path": "vendor/github.com/influxdata/influxdb/monitor/build_info.go",
"chars": 476,
"preview": "package monitor\n\nimport \"github.com/influxdata/influxdb/monitor/diagnostics\"\n\n// build holds information of the build of"
},
{
"path": "vendor/github.com/influxdata/influxdb/monitor/config.go",
"chars": 1754,
"preview": "package monitor\n\nimport (\n\t\"errors\"\n\t\"time\"\n\n\t\"github.com/influxdata/influxdb/monitor/diagnostics\"\n\t\"github.com/influxda"
},
{
"path": "vendor/github.com/influxdata/influxdb/monitor/config_test.go",
"chars": 1247,
"preview": "package monitor_test\n\nimport (\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/BurntSushi/toml\"\n\t\"github.com/influxdata/influxdb/monito"
},
{
"path": "vendor/github.com/influxdata/influxdb/monitor/diagnostics/diagnostics.go",
"chars": 2016,
"preview": "// Package diagnostics provides the diagnostics type so that\n// other packages can provide diagnostics without depending"
},
{
"path": "vendor/github.com/influxdata/influxdb/monitor/go_runtime.go",
"chars": 448,
"preview": "package monitor\n\nimport (\n\t\"runtime\"\n\n\t\"github.com/influxdata/influxdb/monitor/diagnostics\"\n)\n\n// goRuntime captures Go "
}
]
// ... and 1365 more files (download for full content)
About this extraction
This page contains the full source code of the Oxalide/vsphere-influxdb-go GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1565 files (12.8 MB), approximately 3.4M tokens, and a symbol index with 40594 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.