flags

Documentation

Index

• Variables

Variables

var (
	ActiveMQAddress     = FlagSet.String("activemq-address", "", "ActiveMQ STOMP address")
	ActiveMQName        = FlagSet.String("activemq-name", "", "ActiveMQ name")
	ActiveMQEnableTLS   = FlagSet.Bool("activemq-enable-tls", false, "Enable TLS")
	ActiveMQTLSInsecure = FlagSet.Bool("activemq-tls-insecure", false, "Enable TLS insecure")
	ActiveMQTLSCA       = FlagSet.String("activemq-tls-ca-file", "", "TLS CA")
	ActiveMQTLSCert     = FlagSet.String("activemq-tls-cert-file", "", "TLS cert")
	ActiveMQTLSKey      = FlagSet.String("activemq-tls-key-file", "", "TLS key")
)

var (
	AWSRegion     = FlagSet.String("aws-region", "", "AWS region")
	AWSLoadConfig = FlagSet.Bool("aws-load-config", false, "load AWS config from ~/.aws/config")
	AWSRoleARN    = FlagSet.String("aws-role-arn", "", "AWS role ARN")
	SQSQueueURL   = FlagSet.String("aws-sqs-queue-url", "", "AWS SQS queue URL")

	AWSDynamoTable = FlagSet.String("aws-dynamo-table", "", "AWS DynamoDB table name")

	AWSS3Bucket = FlagSet.String("aws-s3-bucket", "", "AWS S3 bucket")
	AWSS3Key    = FlagSet.String("aws-s3-key", "", "AWS S3 key")
	AWSS3ACL    = FlagSet.String("aws-s3-acl", "", "AWS S3 ACL")
	AWSS3Tags   = FlagSet.String("aws-s3-tags", "", "AWS S3 tags. Comma separated list of key=value pairs")
)

var (
	CassandraHosts       = FlagSet.String("cassandra-hosts", "", "Cassandra hosts")
	CassandraUser        = FlagSet.String("cassandra-user", "", "Cassandra user")
	CassandraPassword    = FlagSet.String("cassandra-password", "", "Cassandra password")
	CassandraKeyspace    = FlagSet.String("cassandra-keyspace", "", "Cassandra keyspace")
	CassandraConsistency = FlagSet.String("cassandra-consistency", "QUORUM", "Cassandra consistency")
	CassandraQuery       = FlagSet.String("cassandra-query", "", "Cassandra query")
	CassandraQueryParams = FlagSet.String("cassandra-params", "", "Cassandra query params")
)

var (
	CentauriPeerURL     = FlagSet.String("centauri-peer-url", "", "Centauri peer URL")
	CentauriChannel     = FlagSet.String("centauri-channel", "default", "Centauri channel")
	CentauriKey         = FlagSet.String("centauri-public-key", "", "Centauri public key")
	CentauriKeyBase64   = FlagSet.String("centauri-public-key-base64", "", "Centauri public key base64")
	CentauriMessageType = FlagSet.String("centauri-message-type", "bytes", "Centauri message type. One of: bytes, file")
	CentauriFilename    = FlagSet.String("centauri-filename", "", "Centauri filename")
)

var (
	CockroachDBHost        = FlagSet.String("cockroach-host", "", "CockroachDB host")
	CockroachDBPort        = FlagSet.String("cockroach-port", "26257", "CockroachDB port")
	CockroachDBUser        = FlagSet.String("cockroach-user", "", "CockroachDB user")
	CockroachDBPassword    = FlagSet.String("cockroach-password", "", "CockroachDB password")
	CockroachDBDatabase    = FlagSet.String("cockroach-database", "", "CockroachDB database")
	CockroachDBSSLMode     = FlagSet.String("cockroach-ssl-mode", "disable", "CockroachDB SSL mode")
	CockroachDBQuery       = FlagSet.String("cockroach-query", "", "CockroachDB query")
	CockroachDBQueryParams = FlagSet.String("cockroach-params", "", "CockroachDB query params")
	CockroachDBRoutingID   = FlagSet.String("cockroach-routing-id", "", "CockroachDB routing id")
	CockroachDBTLSRootCert = FlagSet.String("cockroach-tls-root-cert", "", "CockroachDB TLS root cert")
	CockroachDBTLSCert     = FlagSet.String("cockroach-tls-cert", "", "CockroachDB TLS cert")
	CockroachDBTLSKey      = FlagSet.String("cockroach-tls-key", "", "CockroachDB TLS key")
)

var (
	CouchbaseAddress    = FlagSet.String("couchbase-address", "", "Couchbase address")
	CouchbaseUser       = FlagSet.String("couchbase-user", "", "Couchbase user")
	CouchbasePassword   = FlagSet.String("couchbase-password", "", "Couchbase password")
	CouchbaseBucketName = FlagSet.String("couchbase-bucket", "", "Couchbase bucket name")
	CouchbaseScope      = FlagSet.String("couchbase-scope", "_default", "Couchbase scope")
	CouchbaseCollection = FlagSet.String("couchbase-collection", "_default", "Couchbase collection")
	CouchbaseID         = FlagSet.String("couchbase-id", "", "Couchbase id")
	// TLS
	CouchbaseEnableTLS   = FlagSet.Bool("couchbase-enable-tls", false, "Enable TLS")
	CouchbaseTLSInsecure = FlagSet.Bool("couchbase-tls-insecure", false, "Enable TLS insecure")
	CouchbaseCAFile      = FlagSet.String("couchbase-tls-ca-file", "", "Couchbase TLS CA file")
	CouchbaseCertFile    = FlagSet.String("couchbase-tls-cert-file", "", "Couchbase TLS cert file")
	CouchbaseKeyFile     = FlagSet.String("couchbase-tls-key-file", "", "Couchbase TLS key file")
)

var (
	ElasticsearchAddress       = FlagSet.String("elasticsearch-address", "", "Elasticsearch address")
	ElasticsearchUsername      = FlagSet.String("elasticsearch-username", "", "Elasticsearch username")
	ElasticsearchPassword      = FlagSet.String("elasticsearch-password", "", "Elasticsearch password")
	ElasticsearchTLSSkipVerify = FlagSet.Bool("elasticsearch-tls-skip-verify", false, "Elasticsearch TLS skip verify")
	ElasticsearchEnableTLS     = FlagSet.Bool("elasticsearch-enable-tls", false, "Elasticsearch enable TLS")
	ElasticsearchCAFile        = FlagSet.String("elasticsearch-tls-ca-file", "", "Elasticsearch TLS CA file")
	ElasticsearchCertFile      = FlagSet.String("elasticsearch-tls-cert-file", "", "Elasticsearch TLS cert file")
	ElasticsearchKeyFile       = FlagSet.String("elasticsearch-tls-key-file", "", "Elasticsearch TLS key file")
	ElasticsearchIndex         = FlagSet.String("elasticsearch-index", "", "Elasticsearch index")
	ElasticsearchDocID         = FlagSet.String("elasticsearch-doc-id", "", "Elasticsearch doc id")
)

var (
	EtcdHosts       = FlagSet.String("etcd-hosts", "", "Etcd hosts")
	EtcdUsername    = FlagSet.String("etcd-username", "", "Etcd username")
	EtcdPassword    = FlagSet.String("etcd-password", "", "Etcd password")
	EtcdKey         = FlagSet.String("etcd-key", "", "Etcd key")
	EtcdLimit       = FlagSet.Int("etcd-limit", 0, "Etcd limit. 0 for no limit")
	EtcdTLSEnable   = FlagSet.Bool("etcd-tls-enable", false, "Etcd TLS enable")
	EtcdTLSInsecure = FlagSet.Bool("etcd-tls-insecure", false, "Etcd TLS insecure")
	EtcdTLSCert     = FlagSet.String("etcd-tls-cert", "", "Etcd TLS cert")
	EtcdTLSKey      = FlagSet.String("etcd-tls-key", "", "Etcd TLS key")
	EtcdTLSCA       = FlagSet.String("etcd-tls-ca", "", "Etcd TLS ca")
)

var (
	FlagSet   = flag.NewFlagSet("pushx", flag.ContinueOnError)
	Driver    = FlagSet.String("driver", "", "driver to use. (activemq, aws-dynamo, aws-s3, aws-sqs, cassandra, centauri, cockroach, couchbase, elasticsearch, etcd, fs, gcp-bq, gcp-firestore, gcp-gcs, gcp-pubsub, github, http, kafka, local, mongodb, mssql, mysql, nats, nfs, nsq, postgres, pulsar, rabbitmq, redis-list, redis-pubsub, redis-stream, scylla, smb)")
	InputFile = FlagSet.String("in-file", "-", "input file to use. (default: stdin)")
	InputStr  = FlagSet.String("in", "", "input string to use. Will take precedence over -in-file")
	Output    = FlagSet.String("out", "", "output file to use in addition to the driver. If '-' then stdout is used.")
)

var (
	FSKey    = FlagSet.String("fs-key", "", "FS key")
	FSFolder = FlagSet.String("fs-folder", "", "FS folder")
)

var (
	GCPProjectID = FlagSet.String("gcp-project-id", "", "GCP project ID")
	GCPTopic     = FlagSet.String("gcp-pubsub-topic", "", "GCP Pub/Sub topic name")

	GCPFirestoreCollection = FlagSet.String("gcp-firestore-collection", "", "GCP Firestore collection")
	GCPFirestoreID         = FlagSet.String("gcp-firestore-id", "", "GCP Firestore document ID. If empty, a new document ID will be created")

	GCPGCSBucket = FlagSet.String("gcp-gcs-bucket", "", "GCP GCS bucket")
	GCPGCSKey    = FlagSet.String("gcp-gcs-key", "", "GCP GCS key")

	GCPBQQuery = FlagSet.String("gcp-bq-query", "", "GCP BigQuery query")
)

var (
	GitHubRepo          = FlagSet.String("github-repo", "", "GitHub repo")
	GitHubOwner         = FlagSet.String("github-owner", "", "GitHub owner")
	GitHubToken         = FlagSet.String("github-token", "", "GitHub token")
	GitHubFile          = FlagSet.String("github-file", "", "GitHub file")
	GitHubRef           = FlagSet.String("github-ref", "", "GitHub ref")
	GitHubOpenPR        = FlagSet.Bool("github-open-pr", false, "open PR on changes. Default: false")
	GitHubBaseBranch    = FlagSet.String("github-base-branch", "", "base branch for PR")
	GitHubBranch        = FlagSet.String("github-branch", "", "branch for PR.")
	GitHubCommitName    = FlagSet.String("github-commit-name", "", "commit name")
	GitHubCommitEmail   = FlagSet.String("github-commit-email", "", "commit email")
	GitHubCommitMessage = FlagSet.String("github-commit-message", "", "commit message")
	GitHubPRTitle       = FlagSet.String("github-pr-title", "", "PR title")
	GitHubPRBody        = FlagSet.String("github-pr-body", "", "PR body")
)

var (
	HTTPMethod                = FlagSet.String("http-method", "POST", "HTTP method")
	HTTPURL                   = FlagSet.String("http-url", "", "HTTP url")
	HTTPContentType           = FlagSet.String("http-content-type", "", "HTTP content type")
	HTTPSuccessfulStatusCodes = FlagSet.String("http-successful-status-codes", "", "HTTP successful status codes")
	HTTPHeaders               = FlagSet.String("http-headers", "", "HTTP headers")
	HTTPEnableTLS             = FlagSet.Bool("http-enable-tls", false, "HTTP enable tls")
	HTTPTLSInsecure           = FlagSet.Bool("http-tls-insecure", false, "HTTP tls insecure")
	HTTPTLSCertFile           = FlagSet.String("http-tls-cert-file", "", "HTTP tls cert file")
	HTTPTLSKeyFile            = FlagSet.String("http-tls-key-file", "", "HTTP tls key file")
	HTTPTLSCAFile             = FlagSet.String("http-tls-ca-file", "", "HTTP tls ca file")
)

var (
	KafkaBrokers      = FlagSet.String("kafka-brokers", "", "Kafka brokers, comma separated")
	KafkaTopic        = FlagSet.String("kafka-topic", "", "Kafka topic")
	KafkaEnableTLS    = FlagSet.Bool("kafka-enable-tls", false, "Enable TLS")
	KafkaTLSInsecure  = FlagSet.Bool("kafka-tls-insecure", false, "Enable TLS insecure")
	KafkaCAFile       = FlagSet.String("kafka-tls-ca-file", "", "Kafka TLS CA file")
	KafkaCertFile     = FlagSet.String("kafka-tls-cert-file", "", "Kafka TLS cert file")
	KafkaKeyFile      = FlagSet.String("kafka-tls-key-file", "", "Kafka TLS key file")
	KafkaEnableSasl   = FlagSet.Bool("kafka-enable-sasl", false, "Enable SASL")
	KafkaSaslType     = FlagSet.String("kafka-sasl-type", "", "Kafka SASL type. Can be either 'scram' or 'plain'")
	KafkaSaslUsername = FlagSet.String("kafka-sasl-username", "", "Kafka SASL user")
	KafkaSaslPassword = FlagSet.String("kafka-sasl-password", "", "Kafka SASL password")
)

var (
	MongoHost        = FlagSet.String("mongo-host", "", "MongoDB host")
	MongoPort        = FlagSet.String("mongo-port", "27017", "MongoDB port")
	MongoUser        = FlagSet.String("mongo-user", "", "MongoDB user")
	MongoPassword    = FlagSet.String("mongo-password", "", "MongoDB password")
	MongoDatabase    = FlagSet.String("mongo-database", "", "MongoDB database")
	MongoCollection  = FlagSet.String("mongo-collection", "", "MongoDB collection")
	MongoEnableTLS   = FlagSet.Bool("mongo-enable-tls", false, "Enable TLS")
	MongoAuthSource  = FlagSet.String("mongo-auth-source", "", "MongoDB auth source")
	MongoTLSInsecure = FlagSet.Bool("mongo-tls-insecure", false, "Enable TLS insecure")
	MongoCAFile      = FlagSet.String("mongo-tls-ca-file", "", "Mongo TLS CA file")
	MongoCertFile    = FlagSet.String("mongo-tls-cert-file", "", "Mongo TLS cert file")
	MongoKeyFile     = FlagSet.String("mongo-tls-key-file", "", "Mongo TLS key file")
)

var (
	MSSqlHost        = FlagSet.String("mssql-host", "", "MySQL host")
	MSSqlPort        = FlagSet.String("mssql-port", "1433", "MySQL port")
	MSSqlUser        = FlagSet.String("mssql-user", "", "MySQL user")
	MSSqlPassword    = FlagSet.String("mssql-password", "", "MySQL password")
	MSSqlDatabase    = FlagSet.String("mssql-database", "", "MySQL database")
	MSSqlQuery       = FlagSet.String("mssql-query", "", "MySQL query")
	MSSqlQueryParams = FlagSet.String("mssql-params", "", "MySQL query params")
)

var (
	MysqlHost        = FlagSet.String("mysql-host", "", "MySQL host")
	MysqlPort        = FlagSet.String("mysql-port", "3306", "MySQL port")
	MysqlUser        = FlagSet.String("mysql-user", "", "MySQL user")
	MysqlPassword    = FlagSet.String("mysql-password", "", "MySQL password")
	MysqlDatabase    = FlagSet.String("mysql-database", "", "MySQL database")
	MysqlQuery       = FlagSet.String("mysql-query", "", "MySQL query")
	MysqlQueryParams = FlagSet.String("mysql-params", "", "MySQL query params")
)

var (
	NATSURL         = FlagSet.String("nats-url", "", "NATS URL")
	NATSSubject     = FlagSet.String("nats-subject", "", "NATS subject")
	NATSCredsFile   = FlagSet.String("nats-creds-file", "", "NATS creds file")
	NATSJWTFile     = FlagSet.String("nats-jwt-file", "", "NATS JWT file")
	NATSNKeyFile    = FlagSet.String("nats-nkey-file", "", "NATS NKey file")
	NATSUsername    = FlagSet.String("nats-username", "", "NATS username")
	NATSPassword    = FlagSet.String("nats-password", "", "NATS password")
	NATSToken       = FlagSet.String("nats-token", "", "NATS token")
	NATSEnableTLS   = FlagSet.Bool("nats-enable-tls", false, "NATS enable TLS")
	NATSTLSInsecure = FlagSet.Bool("nats-tls-insecure", false, "NATS TLS insecure")
	NATSTLSCAFile   = FlagSet.String("nats-tls-ca-file", "", "NATS TLS CA file")
	NATSTLSCertFile = FlagSet.String("nats-tls-cert-file", "", "NATS TLS cert file")
	NATSTLSKeyFile  = FlagSet.String("nats-tls-key-file", "", "NATS TLS key file")
)

var (
	NFSHost   = FlagSet.String("nfs-host", "", "NFS host")
	NFSKey    = FlagSet.String("nfs-key", "", "NFS key")
	NFSFolder = FlagSet.String("nfs-folder", "", "NFS folder")
	NFSTarget = FlagSet.String("nfs-target", "", "NFS target")
)

var (
	NSQNSQLookupdAddress = FlagSet.String("nsq-nsqlookupd-address", "", "NSQ nsqlookupd address")
	NSQNSQDAddress       = FlagSet.String("nsq-nsqd-address", "", "NSQ nsqd address")
	NSQTopic             = FlagSet.String("nsq-topic", "", "NSQ topic")
	NSQEnableTLS         = FlagSet.Bool("nsq-enable-tls", false, "Enable TLS")
	NSQTLSSkipVerify     = FlagSet.Bool("nsq-tls-skip-verify", false, "NSQ TLS skip verify")
	NSQCAFile            = FlagSet.String("nsq-tls-ca-file", "", "NSQ TLS CA file")
	NSQCertFile          = FlagSet.String("nsq-tls-cert-file", "", "NSQ TLS cert file")
	NSQKeyFile           = FlagSet.String("nsq-tls-key-file", "", "NSQ TLS key file")
)

var (
	PsqlHost        = FlagSet.String("psql-host", "", "PostgreSQL host")
	PsqlPort        = FlagSet.String("psql-port", "5432", "PostgreSQL port")
	PsqlUser        = FlagSet.String("psql-user", "", "PostgreSQL user")
	PsqlPassword    = FlagSet.String("psql-password", "", "PostgreSQL password")
	PsqlDatabase    = FlagSet.String("psql-database", "", "PostgreSQL database")
	PsqlSSLMode     = FlagSet.String("psql-ssl-mode", "disable", "PostgreSQL SSL mode")
	PsqlTLSRootCert = FlagSet.String("psql-tls-root-cert", "", "PostgreSQL TLS root cert")
	PsqlTLSCert     = FlagSet.String("psql-tls-cert", "", "PostgreSQL TLS cert")
	PsqlTLSKey      = FlagSet.String("psql-tls-key", "", "PostgreSQL TLS key")
	PsqlQuery       = FlagSet.String("psql-query", "", "PostgreSQL query")
	PsqlQueryParams = FlagSet.String("psql-params", "", "PostgreSQL query params")
)

var (
	PulsarAddress                    = FlagSet.String("pulsar-address", "", "Pulsar address")
	PulsarTopic                      = FlagSet.String("pulsar-topic", "", "Pulsar topic")
	PulsarProducerName               = FlagSet.String("pulsar-producer-name", "", "Pulsar producer name")
	PulsarTLSTrustCertsFilePath      = FlagSet.String("pulsar-tls-trust-certs-file", "", "Pulsar TLS trust certs file path")
	PulsarTLSAllowInsecureConnection = FlagSet.Bool("pulsar-tls-allow-insecure-connection", false, "Pulsar TLS allow insecure connection")
	PulsarTLSValidateHostname        = FlagSet.Bool("pulsar-tls-validate-hostname", false, "Pulsar TLS validate hostname")
	PulsarAuthToken                  = FlagSet.String("pulsar-auth-token", "", "Pulsar auth token")
	PulsarAuthTokenFile              = FlagSet.String("pulsar-auth-token-file", "", "Pulsar auth token file")
	PulsarAuthCertFile               = FlagSet.String("pulsar-auth-cert-file", "", "Pulsar auth cert file")
	PulsarAuthKeyFile                = FlagSet.String("pulsar-auth-key-file", "", "Pulsar auth key file")
	PulsarAuthOAuthParams            = FlagSet.String("pulsar-auth-oauth-params", "", "Pulsar auth oauth params")
)

var (
	RabbitMQURL      = FlagSet.String("rabbitmq-url", "", "RabbitMQ URL")
	RabbitMQQueue    = FlagSet.String("rabbitmq-queue", "", "RabbitMQ queue")
	RabbitMQExchange = FlagSet.String("rabbitmq-exchange", "", "RabbitMQ exchange")
)

var (
	RedisHost     = FlagSet.String("redis-host", "", "Redis host")
	RedisPort     = FlagSet.String("redis-port", "6379", "Redis port")
	RedisPassword = FlagSet.String("redis-password", "", "Redis password")
	RedisKey      = FlagSet.String("redis-key", "", "Redis key")

	RedisEnableTLS     = FlagSet.Bool("redis-enable-tls", false, "Enable TLS")
	RedisTLSSkipVerify = FlagSet.Bool("redis-tls-skip-verify", false, "Redis TLS skip verify")
	RedisCAFile        = FlagSet.String("redis-tls-ca-file", "", "Redis TLS CA file")
	RedisCertFile      = FlagSet.String("redis-tls-cert-file", "", "Redis TLS cert file")
	RedisKeyFile       = FlagSet.String("redis-tls-key-file", "", "Redis TLS key file")

	RedisMessageID = FlagSet.String("redis-message-id", "*", "Redis stream message id")
)

var (
	ScyllaHosts       = FlagSet.String("scylla-hosts", "", "Scylla hosts")
	ScyllaUser        = FlagSet.String("scylla-user", "", "Scylla user")
	ScyllaPassword    = FlagSet.String("scylla-password", "", "Scylla password")
	ScyllaKeyspace    = FlagSet.String("scylla-keyspace", "", "Scylla keyspace")
	ScyllaConsistency = FlagSet.String("scylla-consistency", "QUORUM", "Scylla consistency")
	ScyllaLocalDC     = FlagSet.String("scylla-local-dc", "", "Scylla local dc")
	ScyllaQuery       = FlagSet.String("scylla-query", "", "Scylla query")
	ScyllaQueryParams = FlagSet.String("scylla-params", "", "Scylla query params")
)

var (
	SMBHost  = FlagSet.String("smb-host", "", "SMB host")
	SMBPort  = FlagSet.Int("smb-port", 445, "SMB port")
	SMBUser  = FlagSet.String("smb-user", "", "SMB user")
	SMBPass  = FlagSet.String("smb-pass", "", "SMB pass")
	SMBKey   = FlagSet.String("smb-key", "", "SMB key")
	SMBShare = FlagSet.String("smb-share", "", "SMB share")
)