hcq/influx-cli
hcq/influx-cli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: v1 dbrp commands (#136)

Browse Source 
* feat: v1 dbrp commands

* fix: fixed the cloud create command

* chore: cleanup

* fix: updated based on required attrs in swagger

* feat: update to latest openapi rev

* chore: made dbrps plural consistently

* chore: formatting

* fix: standardized Default field name and added comments

* chore: changed file name for command to singular
This commit is contained in:
William Baker 2021-06-22 10:07:15 -04:00 committed by GitHub
parent a029bf2871
commit f80b91730d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 3042 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1016
api/api_dbrps.gen.go Normal file
View File

File diff suppressed because it is too large Load Diff

3
api/client.gen.go
View File

@ -53,6 +53,8 @@ type APIClient struct {
BucketsApi BucketsApi
DBRPsApi DBRPsApi
DashboardsApi DashboardsApi
DeleteApi DeleteApi
@ -99,6 +101,7 @@ func NewAPIClient(cfg *Configuration) *APIClient {
c.BackupApi = (*BackupApiService)(&c.common)
c.BucketSchemasApi = (*BucketSchemasApiService)(&c.common)
c.BucketsApi = (*BucketsApiService)(&c.common)
c.DBRPsApi = (*DBRPsApiService)(&c.common)
c.DashboardsApi = (*DashboardsApiService)(&c.common)
c.DeleteApi = (*DeleteApiService)(&c.common)
c.HealthApi = (*HealthApiService)(&c.common)

14
api/contract/cli.yml
View File

@ -77,6 +77,10 @@ paths:
$ref: "./overrides/paths/dashboards.yml"
/templates/export:
$ref: "./overrides/paths/templates_export.yml"
/dbrps:
$ref: "./openapi/src/common/paths/dbrps.yml"
"/dbrps/{dbrpID}":
$ref: "./openapi/src/common/paths/dbrps_dbrpID.yml"
components:
parameters:
TraceSpan:
@ -271,3 +275,13 @@ components:
$ref: "./openapi/src/common/schemas/SecretKeys.yml"
Secrets:
$ref: "./openapi/src/common/schemas/Secrets.yml"
DBRP:
$ref: "./openapi/src/common/schemas/DBRP.yml"
DBRPs:
$ref: "./openapi/src/common/schemas/DBRPs.yml"
DBRPCreate:
$ref: "./openapi/src/common/schemas/DBRPCreate.yml"
DBRPUpdate:
$ref: "./openapi/src/common/schemas/DBRPUpdate.yml"
DBRPGet:
$ref: "./openapi/src/common/schemas/DBRPGet.yml"

2
api/contract/openapi

@ -1 +1 @@
Subproject commit 1060f69e9ffd3307a6db63c817cd51a82ff73fc4
Subproject commit d9aa0f1136d17956f45ebb63717220214933d477

293
api/model_dbrp.gen.go Normal file
View File

@ -0,0 +1,293 @@
/*
* Subset of Influx API covered by Influx CLI
*
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* API version: 2.0.0
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package api
import (
"encoding/json"
)
// DBRP struct for DBRP
type DBRP struct {
// the mapping identifier
Id string `json:"id"`
// the organization ID that owns this mapping.
OrgID string `json:"orgID"`
// the bucket ID used as target for the translation.
BucketID string `json:"bucketID"`
// InfluxDB v1 database
Database string `json:"database"`
// InfluxDB v1 retention policy
RetentionPolicy string `json:"retention_policy"`
// Specify if this mapping represents the default retention policy for the database specificed.
Default bool `json:"default"`
Links *Links `json:"links,omitempty"`
}
// NewDBRP instantiates a new DBRP object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewDBRP(id string, orgID string, bucketID string, database string, retentionPolicy string, default_ bool) *DBRP {
this := DBRP{}
this.Id = id
this.OrgID = orgID
this.BucketID = bucketID
this.Database = database
this.RetentionPolicy = retentionPolicy
this.Default = default_
return &this
}
// NewDBRPWithDefaults instantiates a new DBRP object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewDBRPWithDefaults() *DBRP {
this := DBRP{}
return &this
}
// GetId returns the Id field value
func (o *DBRP) GetId() string {
if o == nil {
var ret string
return ret
}
return o.Id
}
// GetIdOk returns a tuple with the Id field value
// and a boolean to check if the value has been set.
func (o *DBRP) GetIdOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.Id, true
}
// SetId sets field value
func (o *DBRP) SetId(v string) {
o.Id = v
}
// GetOrgID returns the OrgID field value
func (o *DBRP) GetOrgID() string {
if o == nil {
var ret string
return ret
}
return o.OrgID
}
// GetOrgIDOk returns a tuple with the OrgID field value
// and a boolean to check if the value has been set.
func (o *DBRP) GetOrgIDOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.OrgID, true
}
// SetOrgID sets field value
func (o *DBRP) SetOrgID(v string) {
o.OrgID = v
}
// GetBucketID returns the BucketID field value
func (o *DBRP) GetBucketID() string {
if o == nil {
var ret string
return ret
}
return o.BucketID
}
// GetBucketIDOk returns a tuple with the BucketID field value
// and a boolean to check if the value has been set.
func (o *DBRP) GetBucketIDOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.BucketID, true
}
// SetBucketID sets field value
func (o *DBRP) SetBucketID(v string) {
o.BucketID = v
}
// GetDatabase returns the Database field value
func (o *DBRP) GetDatabase() string {
if o == nil {
var ret string
return ret
}
return o.Database
}
// GetDatabaseOk returns a tuple with the Database field value
// and a boolean to check if the value has been set.
func (o *DBRP) GetDatabaseOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.Database, true
}
// SetDatabase sets field value
func (o *DBRP) SetDatabase(v string) {
o.Database = v
}
// GetRetentionPolicy returns the RetentionPolicy field value
func (o *DBRP) GetRetentionPolicy() string {
if o == nil {
var ret string
return ret
}
return o.RetentionPolicy
}
// GetRetentionPolicyOk returns a tuple with the RetentionPolicy field value
// and a boolean to check if the value has been set.
func (o *DBRP) GetRetentionPolicyOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.RetentionPolicy, true
}
// SetRetentionPolicy sets field value
func (o *DBRP) SetRetentionPolicy(v string) {
o.RetentionPolicy = v
}
// GetDefault returns the Default field value
func (o *DBRP) GetDefault() bool {
if o == nil {
var ret bool
return ret
}
return o.Default
}
// GetDefaultOk returns a tuple with the Default field value
// and a boolean to check if the value has been set.
func (o *DBRP) GetDefaultOk() (*bool, bool) {
if o == nil {
return nil, false
}
return &o.Default, true
}
// SetDefault sets field value
func (o *DBRP) SetDefault(v bool) {
o.Default = v
}
// GetLinks returns the Links field value if set, zero value otherwise.
func (o *DBRP) GetLinks() Links {
if o == nil || o.Links == nil {
var ret Links
return ret
}
return *o.Links
}
// GetLinksOk returns a tuple with the Links field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRP) GetLinksOk() (*Links, bool) {
if o == nil || o.Links == nil {
return nil, false
}
return o.Links, true
}
// HasLinks returns a boolean if a field has been set.
func (o *DBRP) HasLinks() bool {
if o != nil && o.Links != nil {
return true
}
return false
}
// SetLinks gets a reference to the given Links and assigns it to the Links field.
func (o *DBRP) SetLinks(v Links) {
o.Links = &v
}
func (o DBRP) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if true {
toSerialize["id"] = o.Id
}
if true {
toSerialize["orgID"] = o.OrgID
}
if true {
toSerialize["bucketID"] = o.BucketID
}
if true {
toSerialize["database"] = o.Database
}
if true {
toSerialize["retention_policy"] = o.RetentionPolicy
}
if true {
toSerialize["default"] = o.Default
}
if o.Links != nil {
toSerialize["links"] = o.Links
}
return json.Marshal(toSerialize)
}
type NullableDBRP struct {
value *DBRP
isSet bool
}
func (v NullableDBRP) Get() *DBRP {
return v.value
}
func (v *NullableDBRP) Set(val *DBRP) {
v.value = val
v.isSet = true
}
func (v NullableDBRP) IsSet() bool {
return v.isSet
}
func (v *NullableDBRP) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableDBRP(val *DBRP) *NullableDBRP {
return &NullableDBRP{value: val, isSet: true}
}
func (v NullableDBRP) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableDBRP) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
}

278
api/model_dbrp_create.gen.go Normal file
View File

@ -0,0 +1,278 @@
/*
* Subset of Influx API covered by Influx CLI
*
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* API version: 2.0.0
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package api
import (
"encoding/json"
)
// DBRPCreate struct for DBRPCreate
type DBRPCreate struct {
// the organization ID that owns this mapping.
OrgID *string `json:"orgID,omitempty"`
// the organization that owns this mapping.
Org *string `json:"org,omitempty"`
// the bucket ID used as target for the translation.
BucketID string `json:"bucketID"`
// InfluxDB v1 database
Database string `json:"database"`
// InfluxDB v1 retention policy
RetentionPolicy string `json:"retention_policy"`
// Specify if this mapping represents the default retention policy for the database specificed.
Default *bool `json:"default,omitempty"`
}
// NewDBRPCreate instantiates a new DBRPCreate object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewDBRPCreate(bucketID string, database string, retentionPolicy string) *DBRPCreate {
this := DBRPCreate{}
this.BucketID = bucketID
this.Database = database
this.RetentionPolicy = retentionPolicy
return &this
}
// NewDBRPCreateWithDefaults instantiates a new DBRPCreate object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewDBRPCreateWithDefaults() *DBRPCreate {
this := DBRPCreate{}
return &this
}
// GetOrgID returns the OrgID field value if set, zero value otherwise.
func (o *DBRPCreate) GetOrgID() string {
if o == nil || o.OrgID == nil {
var ret string
return ret
}
return *o.OrgID
}
// GetOrgIDOk returns a tuple with the OrgID field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPCreate) GetOrgIDOk() (*string, bool) {
if o == nil || o.OrgID == nil {
return nil, false
}
return o.OrgID, true
}
// HasOrgID returns a boolean if a field has been set.
func (o *DBRPCreate) HasOrgID() bool {
if o != nil && o.OrgID != nil {
return true
}
return false
}
// SetOrgID gets a reference to the given string and assigns it to the OrgID field.
func (o *DBRPCreate) SetOrgID(v string) {
o.OrgID = &v
}
// GetOrg returns the Org field value if set, zero value otherwise.
func (o *DBRPCreate) GetOrg() string {
if o == nil || o.Org == nil {
var ret string
return ret
}
return *o.Org
}
// GetOrgOk returns a tuple with the Org field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPCreate) GetOrgOk() (*string, bool) {
if o == nil || o.Org == nil {
return nil, false
}
return o.Org, true
}
// HasOrg returns a boolean if a field has been set.
func (o *DBRPCreate) HasOrg() bool {
if o != nil && o.Org != nil {
return true
}
return false
}
// SetOrg gets a reference to the given string and assigns it to the Org field.
func (o *DBRPCreate) SetOrg(v string) {
o.Org = &v
}
// GetBucketID returns the BucketID field value
func (o *DBRPCreate) GetBucketID() string {
if o == nil {
var ret string
return ret
}
return o.BucketID
}
// GetBucketIDOk returns a tuple with the BucketID field value
// and a boolean to check if the value has been set.
func (o *DBRPCreate) GetBucketIDOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.BucketID, true
}
// SetBucketID sets field value
func (o *DBRPCreate) SetBucketID(v string) {
o.BucketID = v
}
// GetDatabase returns the Database field value
func (o *DBRPCreate) GetDatabase() string {
if o == nil {
var ret string
return ret
}
return o.Database
}
// GetDatabaseOk returns a tuple with the Database field value
// and a boolean to check if the value has been set.
func (o *DBRPCreate) GetDatabaseOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.Database, true
}
// SetDatabase sets field value
func (o *DBRPCreate) SetDatabase(v string) {
o.Database = v
}
// GetRetentionPolicy returns the RetentionPolicy field value
func (o *DBRPCreate) GetRetentionPolicy() string {
if o == nil {
var ret string
return ret
}
return o.RetentionPolicy
}
// GetRetentionPolicyOk returns a tuple with the RetentionPolicy field value
// and a boolean to check if the value has been set.
func (o *DBRPCreate) GetRetentionPolicyOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.RetentionPolicy, true
}
// SetRetentionPolicy sets field value
func (o *DBRPCreate) SetRetentionPolicy(v string) {
o.RetentionPolicy = v
}
// GetDefault returns the Default field value if set, zero value otherwise.
func (o *DBRPCreate) GetDefault() bool {
if o == nil || o.Default == nil {
var ret bool
return ret
}
return *o.Default
}
// GetDefaultOk returns a tuple with the Default field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPCreate) GetDefaultOk() (*bool, bool) {
if o == nil || o.Default == nil {
return nil, false
}
return o.Default, true
}
// HasDefault returns a boolean if a field has been set.
func (o *DBRPCreate) HasDefault() bool {
if o != nil && o.Default != nil {
return true
}
return false
}
// SetDefault gets a reference to the given bool and assigns it to the Default field.
func (o *DBRPCreate) SetDefault(v bool) {
o.Default = &v
}
func (o DBRPCreate) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.OrgID != nil {
toSerialize["orgID"] = o.OrgID
}
if o.Org != nil {
toSerialize["org"] = o.Org
}
if true {
toSerialize["bucketID"] = o.BucketID
}
if true {
toSerialize["database"] = o.Database
}
if true {
toSerialize["retention_policy"] = o.RetentionPolicy
}
if o.Default != nil {
toSerialize["default"] = o.Default
}
return json.Marshal(toSerialize)
}
type NullableDBRPCreate struct {
value *DBRPCreate
isSet bool
}
func (v NullableDBRPCreate) Get() *DBRPCreate {
return v.value
}
func (v *NullableDBRPCreate) Set(val *DBRPCreate) {
v.value = val
v.isSet = true
}
func (v NullableDBRPCreate) IsSet() bool {
return v.isSet
}
func (v *NullableDBRPCreate) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableDBRPCreate(val *DBRPCreate) *NullableDBRPCreate {
return &NullableDBRPCreate{value: val, isSet: true}
}
func (v NullableDBRPCreate) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableDBRPCreate) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
}

113
api/model_dbrp_get.gen.go Normal file
View File

@ -0,0 +1,113 @@
/*
* Subset of Influx API covered by Influx CLI
*
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* API version: 2.0.0
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package api
import (
"encoding/json"
)
// DBRPGet struct for DBRPGet
type DBRPGet struct {
Content *DBRP `json:"content,omitempty"`
}
// NewDBRPGet instantiates a new DBRPGet object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewDBRPGet() *DBRPGet {
this := DBRPGet{}
return &this
}
// NewDBRPGetWithDefaults instantiates a new DBRPGet object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewDBRPGetWithDefaults() *DBRPGet {
this := DBRPGet{}
return &this
}
// GetContent returns the Content field value if set, zero value otherwise.
func (o *DBRPGet) GetContent() DBRP {
if o == nil || o.Content == nil {
var ret DBRP
return ret
}
return *o.Content
}
// GetContentOk returns a tuple with the Content field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPGet) GetContentOk() (*DBRP, bool) {
if o == nil || o.Content == nil {
return nil, false
}
return o.Content, true
}
// HasContent returns a boolean if a field has been set.
func (o *DBRPGet) HasContent() bool {
if o != nil && o.Content != nil {
return true
}
return false
}
// SetContent gets a reference to the given DBRP and assigns it to the Content field.
func (o *DBRPGet) SetContent(v DBRP) {
o.Content = &v
}
func (o DBRPGet) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.Content != nil {
toSerialize["content"] = o.Content
}
return json.Marshal(toSerialize)
}
type NullableDBRPGet struct {
value *DBRPGet
isSet bool
}
func (v NullableDBRPGet) Get() *DBRPGet {
return v.value
}
func (v *NullableDBRPGet) Set(val *DBRPGet) {
v.value = val
v.isSet = true
}
func (v NullableDBRPGet) IsSet() bool {
return v.isSet
}
func (v *NullableDBRPGet) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableDBRPGet(val *DBRPGet) *NullableDBRPGet {
return &NullableDBRPGet{value: val, isSet: true}
}
func (v NullableDBRPGet) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableDBRPGet) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
}

150
api/model_dbrp_update.gen.go Normal file
View File

@ -0,0 +1,150 @@
/*
* Subset of Influx API covered by Influx CLI
*
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* API version: 2.0.0
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package api
import (
"encoding/json"
)
// DBRPUpdate struct for DBRPUpdate
type DBRPUpdate struct {
// InfluxDB v1 retention policy
RetentionPolicy *string `json:"retention_policy,omitempty"`
Default *bool `json:"default,omitempty"`
}
// NewDBRPUpdate instantiates a new DBRPUpdate object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewDBRPUpdate() *DBRPUpdate {
this := DBRPUpdate{}
return &this
}
// NewDBRPUpdateWithDefaults instantiates a new DBRPUpdate object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewDBRPUpdateWithDefaults() *DBRPUpdate {
this := DBRPUpdate{}
return &this
}
// GetRetentionPolicy returns the RetentionPolicy field value if set, zero value otherwise.
func (o *DBRPUpdate) GetRetentionPolicy() string {
if o == nil || o.RetentionPolicy == nil {
var ret string
return ret
}
return *o.RetentionPolicy
}
// GetRetentionPolicyOk returns a tuple with the RetentionPolicy field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPUpdate) GetRetentionPolicyOk() (*string, bool) {
if o == nil || o.RetentionPolicy == nil {
return nil, false
}
return o.RetentionPolicy, true
}
// HasRetentionPolicy returns a boolean if a field has been set.
func (o *DBRPUpdate) HasRetentionPolicy() bool {
if o != nil && o.RetentionPolicy != nil {
return true
}
return false
}
// SetRetentionPolicy gets a reference to the given string and assigns it to the RetentionPolicy field.
func (o *DBRPUpdate) SetRetentionPolicy(v string) {
o.RetentionPolicy = &v
}
// GetDefault returns the Default field value if set, zero value otherwise.
func (o *DBRPUpdate) GetDefault() bool {
if o == nil || o.Default == nil {
var ret bool
return ret
}
return *o.Default
}
// GetDefaultOk returns a tuple with the Default field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPUpdate) GetDefaultOk() (*bool, bool) {
if o == nil || o.Default == nil {
return nil, false
}
return o.Default, true
}
// HasDefault returns a boolean if a field has been set.
func (o *DBRPUpdate) HasDefault() bool {
if o != nil && o.Default != nil {
return true
}
return false
}
// SetDefault gets a reference to the given bool and assigns it to the Default field.
func (o *DBRPUpdate) SetDefault(v bool) {
o.Default = &v
}
func (o DBRPUpdate) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.RetentionPolicy != nil {
toSerialize["retention_policy"] = o.RetentionPolicy
}
if o.Default != nil {
toSerialize["default"] = o.Default
}
return json.Marshal(toSerialize)
}
type NullableDBRPUpdate struct {
value *DBRPUpdate
isSet bool
}
func (v NullableDBRPUpdate) Get() *DBRPUpdate {
return v.value
}
func (v *NullableDBRPUpdate) Set(val *DBRPUpdate) {
v.value = val
v.isSet = true
}
func (v NullableDBRPUpdate) IsSet() bool {
return v.isSet
}
func (v *NullableDBRPUpdate) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableDBRPUpdate(val *DBRPUpdate) *NullableDBRPUpdate {
return &NullableDBRPUpdate{value: val, isSet: true}
}
func (v NullableDBRPUpdate) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableDBRPUpdate) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
}

113
api/model_dbrps.gen.go Normal file
View File

@ -0,0 +1,113 @@
/*
* Subset of Influx API covered by Influx CLI
*
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* API version: 2.0.0
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package api
import (
"encoding/json"
)
// DBRPs struct for DBRPs
type DBRPs struct {
Content *[]DBRP `json:"content,omitempty"`
}
// NewDBRPs instantiates a new DBRPs object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewDBRPs() *DBRPs {
this := DBRPs{}
return &this
}
// NewDBRPsWithDefaults instantiates a new DBRPs object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewDBRPsWithDefaults() *DBRPs {
this := DBRPs{}
return &this
}
// GetContent returns the Content field value if set, zero value otherwise.
func (o *DBRPs) GetContent() []DBRP {
if o == nil || o.Content == nil {
var ret []DBRP
return ret
}
return *o.Content
}
// GetContentOk returns a tuple with the Content field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *DBRPs) GetContentOk() (*[]DBRP, bool) {
if o == nil || o.Content == nil {
return nil, false
}
return o.Content, true
}
// HasContent returns a boolean if a field has been set.
func (o *DBRPs) HasContent() bool {
if o != nil && o.Content != nil {
return true
}
return false
}
// SetContent gets a reference to the given []DBRP and assigns it to the Content field.
func (o *DBRPs) SetContent(v []DBRP) {
o.Content = &v
}
func (o DBRPs) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.Content != nil {
toSerialize["content"] = o.Content
}
return json.Marshal(toSerialize)
}
type NullableDBRPs struct {
value *DBRPs
isSet bool
}
func (v NullableDBRPs) Get() *DBRPs {
return v.value
}
func (v *NullableDBRPs) Set(val *DBRPs) {
v.value = val
v.isSet = true
}
func (v NullableDBRPs) IsSet() bool {
return v.isSet
}
func (v *NullableDBRPs) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableDBRPs(val *DBRPs) *NullableDBRPs {
return &NullableDBRPs{value: val, isSet: true}
}
func (v NullableDBRPs) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableDBRPs) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
}

249
clients/v1_dbrps/v1_dbrps.go Normal file
View File

@ -0,0 +1,249 @@
package v1dbrps
import (
"context"
"fmt"
"github.com/influxdata/influx-cli/v2/api"
"github.com/influxdata/influx-cli/v2/clients"
)
type Client struct {
clients.CLI
api.DBRPsApi
api.OrganizationsApi
}
type dbrpPrintOpts struct {
dbrp *api.DBRP
dbrps []api.DBRP
}
type ListParams struct {
clients.OrgParams
ID string
BucketID string
Default bool
DB string
RP string
}
func (c Client) List(ctx context.Context, params *ListParams) error {
if !params.OrgID.Valid() && params.OrgName == "" && c.ActiveConfig.Org == "" {
return clients.ErrMustSpecifyOrg
}
req := c.GetDBRPs(ctx)
if params.OrgID.Valid() {
req = req.OrgID(params.OrgID.String())
}
if params.OrgName != "" {
req = req.Org(params.OrgName)
}
if !params.OrgID.Valid() && params.OrgName == "" {
req = req.Org(c.ActiveConfig.Org)
}
if params.ID != "" {
req = req.Id(params.ID)
}
if params.BucketID != "" {
req = req.BucketID(params.BucketID)
}
if params.RP != "" {
req = req.Rp(params.RP)
}
if params.DB != "" {
req = req.Db(params.DB)
}
// Set this parameter if the --default flag was passed. This will list only
// default DBRPs. Otherwise, don't set the parameter at all to list DBRPs that
// are default and not default.
if params.Default {
req = req.Default_(params.Default) // Note: codegen sets this property as "Default_" instead of "Default"
}
dbrps, err := req.Execute()
if err != nil {
return fmt.Errorf("failed to list dbrps: %w", err)
}
c.printDBRPs(dbrpPrintOpts{dbrps: dbrps.GetContent()})
return nil
}
type CreateParams struct {
clients.OrgParams
BucketID string
Default bool
DB string
RP string
}
func (c Client) Create(ctx context.Context, params *CreateParams) error {
if !params.OrgID.Valid() && params.OrgName == "" && c.ActiveConfig.Org == "" {
return clients.ErrMustSpecifyOrg
}
reqBody := api.DBRPCreate{
BucketID: params.BucketID,
Database: params.DB,
RetentionPolicy: params.RP,
}
// For compatibility with the cloud API for creating a DBRP, an org ID must be
// provided. The ID will be obtained based on the org name if an
// org name is provided but no ID is.
if params.OrgID.Valid() {
reqBody.OrgID = api.PtrString(params.OrgID.String())
} else {
orgName := params.OrgName
if orgName == "" {
orgName = c.ActiveConfig.Org
}
res, err := c.GetOrgs(ctx).Org(orgName).Execute()
if err != nil {
return fmt.Errorf("failed to look up ID for org %q: %w", orgName, err)
}
if len(res.GetOrgs()) == 0 {
return fmt.Errorf("no org found with name %q", orgName)
}
reqBody.OrgID = api.PtrString(res.GetOrgs()[0].GetId())
}
dbrp, err := c.PostDBRP(ctx).DBRPCreate(reqBody).Execute()
if err != nil {
return fmt.Errorf("failed to create dbrp for bucket %q: %w", params.BucketID, err)
}
c.printDBRPs(dbrpPrintOpts{dbrp: &dbrp})
return nil
}
type UpdateParams struct {
clients.OrgParams
ID string
Default bool
RP string
}
func (c Client) Update(ctx context.Context, params *UpdateParams) error {
if !params.OrgID.Valid() && params.OrgName == "" && c.ActiveConfig.Org == "" {
return clients.ErrMustSpecifyOrg
}
reqBody := api.DBRPUpdate{}
if params.RP != "" {
reqBody.RetentionPolicy = &params.RP
}
if params.Default {
reqBody.Default = &params.Default
}
req := c.PatchDBRPID(ctx, params.ID)
if params.OrgID.Valid() {
req = req.OrgID(params.OrgID.String())
}
if params.OrgName != "" {
req = req.Org(params.OrgName)
}
if !params.OrgID.Valid() && params.OrgName == "" {
req = req.Org(c.ActiveConfig.Org)
}
dbrp, err := req.DBRPUpdate(reqBody).Execute()
if err != nil {
return fmt.Errorf("failed to update DBRP mapping %q: %w", params.ID, err)
}
dbrpContent := dbrp.GetContent()
c.printDBRPs(dbrpPrintOpts{dbrp: &dbrpContent})
return nil
}
type DeleteParams struct {
clients.OrgParams
ID string
}
func (c Client) Delete(ctx context.Context, params *DeleteParams) error {
if !params.OrgID.Valid() && params.OrgName == "" && c.ActiveConfig.Org == "" {
return clients.ErrMustSpecifyOrg
}
// Get the DBRP to verify that it exists, and to be able to print the results
// of the delete command, which output the details of the deleted DBRP.
getReq := c.GetDBRPsID(ctx, params.ID)
deleteReq := c.DeleteDBRPID(ctx, params.ID)
// The org name or ID must be set on requests for OSS because of how the OSS
// authorization mechanism currently works.
if params.OrgID.Valid() {
getReq = getReq.OrgID(params.OrgID.String())
deleteReq = deleteReq.OrgID(params.OrgID.String())
}
if params.OrgName != "" {
getReq = getReq.Org(params.OrgName)
deleteReq = deleteReq.Org(params.OrgName)
}
if !params.OrgID.Valid() && params.OrgName == "" {
getReq = getReq.Org(c.ActiveConfig.Org)
deleteReq = deleteReq.Org(c.ActiveConfig.Org)
}
dbrp, err := getReq.Execute()
if err != nil {
return fmt.Errorf("failed to find DBRP mapping %q: %w", params.ID, err)
}
if err := deleteReq.Execute(); err != nil {
return fmt.Errorf("failed to delete DBRP mapping %q: %w", params.ID, err)
}
dbrpContent := dbrp.GetContent()
c.printDBRPs(dbrpPrintOpts{dbrp: &dbrpContent})
return nil
}
func (c Client) printDBRPs(opts dbrpPrintOpts) error {
if c.PrintAsJSON {
var v interface{} = opts.dbrps
if opts.dbrp != nil {
v = opts.dbrp
}
return c.PrintJSON(v)
}
headers := []string{
"ID",
"Database",
"Bucket ID",
"Retention Policy",
"Default",
"Organization ID",
}
if opts.dbrp != nil {
opts.dbrps = append(opts.dbrps, *opts.dbrp)
}
var rows []map[string]interface{}
for _, t := range opts.dbrps {
row := map[string]interface{}{
"ID": t.Id,
"Database": t.Database,
"Retention Policy": t.RetentionPolicy,
"Default": t.Default,
"Organization ID": t.OrgID,
"Bucket ID": t.BucketID,
}
rows = append(rows, row)
}
return c.PrintTable(headers, rows...)
}

461
clients/v1_dbrps/v1_dbrps_test.go Normal file
View File

@ -0,0 +1,461 @@
package v1dbrps_test
import (
"bytes"
"context"
"errors"
"fmt"
"strings"
"testing"
"github.com/golang/mock/gomock"
"github.com/influxdata/influx-cli/v2/api"
"github.com/influxdata/influx-cli/v2/clients"
v1dbrps "github.com/influxdata/influx-cli/v2/clients/v1_dbrps"
"github.com/influxdata/influx-cli/v2/internal/mock"
"github.com/influxdata/influx-cli/v2/internal/testutils"
"github.com/influxdata/influx-cli/v2/pkg/influxid"
"github.com/stretchr/testify/require"
)
var (
id1, _ = influxid.IDFromString("1111111111111111")
errApiTest = errors.New("api error for testing")
)
func TestClient_List(t *testing.T) {
t.Parallel()
testCases := []struct {
name string
params v1dbrps.ListParams
registerExpectations func(*testing.T, *mock.MockDBRPsApi)
expectedError error
outLines []string
}{
{
name: "no org id or org name",
params: v1dbrps.ListParams{},
expectedError: clients.ErrMustSpecifyOrg,
},
{
name: "no results",
params: v1dbrps.ListParams{
OrgParams: clients.OrgParams{
OrgID: id1,
},
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPs(gomock.Any()).Return(api.ApiGetDBRPsRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsExecute(gomock.Any()).Return(api.DBRPs{}, nil)
},
},
{
name: "many results",
params: v1dbrps.ListParams{
OrgParams: clients.OrgParams{
OrgName: "example-org",
},
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPs(gomock.Any()).Return(api.ApiGetDBRPsRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsExecute(gomock.Any()).Return(api.DBRPs{
Content: &[]api.DBRP{
{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
},
{
Id: "234",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: true,
OrgID: "1234123412341234",
},
},
}, nil)
},
outLines: []string{
`123\s+someDB\s+456\s+someRP\s+false\s+1234123412341234`,
`234\s+someDB\s+456\s+someRP\s+true\s+1234123412341234`,
},
},
{
name: "api error",
params: v1dbrps.ListParams{
OrgParams: clients.OrgParams{
OrgName: "someOrg",
},
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPs(gomock.Any()).Return(api.ApiGetDBRPsRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsExecute(gomock.Any()).Return(api.DBRPs{}, errApiTest)
},
expectedError: fmt.Errorf("failed to list dbrps: %w", errApiTest),
},
}
for _, tc := range testCases {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
DBRPsApi := mock.NewMockDBRPsApi(ctrl)
if tc.registerExpectations != nil {
tc.registerExpectations(t, DBRPsApi)
}
stdout := bytes.Buffer{}
stdio := mock.NewMockStdIO(ctrl)
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
cli := v1dbrps.Client{CLI: clients.CLI{StdIO: stdio}, DBRPsApi: DBRPsApi}
err := cli.List(context.Background(), &tc.params)
require.Equal(t, tc.expectedError, err)
if tc.expectedError == nil {
testutils.MatchLines(t, append([]string{`ID\s+Database\s+Bucket\s+ID\s+Retention Policy\s+Default\s+Organization ID`}, tc.outLines...), strings.Split(stdout.String(), "\n"))
}
})
}
}
func TestClient_Create(t *testing.T) {
t.Parallel()
testCases := []struct {
name string
params v1dbrps.CreateParams
registerExpectations func(*testing.T, *mock.MockDBRPsApi)
expectedError error
outLines []string
}{
{
name: "no org id or org name",
params: v1dbrps.CreateParams{},
expectedError: clients.ErrMustSpecifyOrg,
},
{
name: "create with org id",
params: v1dbrps.CreateParams{
OrgParams: clients.OrgParams{
OrgID: id1,
},
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().PostDBRP(gomock.Any()).Return(api.ApiPostDBRPRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().PostDBRPExecute(gomock.Any()).Return(api.DBRP{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
}, nil)
},
outLines: []string{
`123\s+someDB\s+456\s+someRP\s+false\s+1234123412341234`,
},
},
{
name: "api error",
params: v1dbrps.CreateParams{
OrgParams: clients.OrgParams{
OrgID: id1,
},
BucketID: "1234",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().PostDBRP(gomock.Any()).Return(api.ApiPostDBRPRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().PostDBRPExecute(gomock.Any()).Return(api.DBRP{}, errApiTest)
},
expectedError: fmt.Errorf("failed to create dbrp for bucket %q: %w", "1234", errApiTest),
},
}
for _, tc := range testCases {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
DBRPsApi := mock.NewMockDBRPsApi(ctrl)
if tc.registerExpectations != nil {
tc.registerExpectations(t, DBRPsApi)
}
stdout := bytes.Buffer{}
stdio := mock.NewMockStdIO(ctrl)
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
cli := v1dbrps.Client{CLI: clients.CLI{StdIO: stdio}, DBRPsApi: DBRPsApi}
err := cli.Create(context.Background(), &tc.params)
require.Equal(t, tc.expectedError, err)
if tc.expectedError == nil {
testutils.MatchLines(t, append([]string{`ID\s+Database\s+Bucket\s+ID\s+Retention Policy\s+Default\s+Organization ID`}, tc.outLines...), strings.Split(stdout.String(), "\n"))
}
})
}
}
func TestClient_Update(t *testing.T) {
t.Parallel()
testCases := []struct {
name string
params v1dbrps.UpdateParams
registerExpectations func(*testing.T, *mock.MockDBRPsApi)
expectedError error
outLines []string
}{
{
name: "no org id or org name",
params: v1dbrps.UpdateParams{},
expectedError: clients.ErrMustSpecifyOrg,
},
{
name: "update with org id",
params: v1dbrps.UpdateParams{
OrgParams: clients.OrgParams{
OrgID: id1,
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().PatchDBRPID(gomock.Any(), "123").Return(api.ApiPatchDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().PatchDBRPIDExecute(gomock.Any()).Return(api.DBRPGet{
Content: &api.DBRP{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
},
}, nil)
},
outLines: []string{
`123\s+someDB\s+456\s+someRP\s+false\s+1234123412341234`,
},
},
{
name: "update with org name",
params: v1dbrps.UpdateParams{
OrgParams: clients.OrgParams{
OrgName: "someOrg",
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().PatchDBRPID(gomock.Any(), "123").Return(api.ApiPatchDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().PatchDBRPIDExecute(gomock.Any()).Return(api.DBRPGet{
Content: &api.DBRP{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
},
}, nil)
},
outLines: []string{
`123\s+someDB\s+456\s+someRP\s+false\s+1234123412341234`,
},
},
{
name: "api error",
params: v1dbrps.UpdateParams{
OrgParams: clients.OrgParams{
OrgName: "someOrg",
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().PatchDBRPID(gomock.Any(), "123").Return(api.ApiPatchDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().PatchDBRPIDExecute(gomock.Any()).Return(api.DBRPGet{}, errApiTest)
},
expectedError: fmt.Errorf("failed to update DBRP mapping %q: %w", "123", errApiTest),
},
}
for _, tc := range testCases {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
DBRPsApi := mock.NewMockDBRPsApi(ctrl)
if tc.registerExpectations != nil {
tc.registerExpectations(t, DBRPsApi)
}
stdout := bytes.Buffer{}
stdio := mock.NewMockStdIO(ctrl)
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
cli := v1dbrps.Client{CLI: clients.CLI{StdIO: stdio}, DBRPsApi: DBRPsApi}
err := cli.Update(context.Background(), &tc.params)
require.Equal(t, tc.expectedError, err)
if tc.expectedError == nil {
testutils.MatchLines(t, append([]string{`ID\s+Database\s+Bucket\s+ID\s+Retention Policy\s+Default\s+Organization ID`}, tc.outLines...), strings.Split(stdout.String(), "\n"))
}
})
}
}
func TestClient_Delete(t *testing.T) {
t.Parallel()
testCases := []struct {
name string
params v1dbrps.DeleteParams
registerExpectations func(*testing.T, *mock.MockDBRPsApi)
expectedError error
outLines []string
}{
{
name: "no org id or org name",
params: v1dbrps.DeleteParams{},
expectedError: clients.ErrMustSpecifyOrg,
},
{
name: "delete with org id",
params: v1dbrps.DeleteParams{
OrgParams: clients.OrgParams{
OrgID: id1,
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPsID(gomock.Any(), "123").Return(api.ApiGetDBRPsIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().DeleteDBRPID(gomock.Any(), "123").Return(api.ApiDeleteDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsIDExecute(gomock.Any()).Return(api.DBRPGet{
Content: &api.DBRP{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
},
}, nil)
DBRPsApi.EXPECT().DeleteDBRPIDExecute(gomock.Any()).Return(nil)
},
outLines: []string{
`123\s+someDB\s+456\s+someRP\s+false\s+1234123412341234`,
},
},
{
name: "delete with org name",
params: v1dbrps.DeleteParams{
OrgParams: clients.OrgParams{
OrgName: "someOrg",
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPsID(gomock.Any(), "123").Return(api.ApiGetDBRPsIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().DeleteDBRPID(gomock.Any(), "123").Return(api.ApiDeleteDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsIDExecute(gomock.Any()).Return(api.DBRPGet{
Content: &api.DBRP{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
},
}, nil)
DBRPsApi.EXPECT().DeleteDBRPIDExecute(gomock.Any()).Return(nil)
},
outLines: []string{
`123\s+someDB\s+456\s+someRP\s+false\s+1234123412341234`,
},
},
{
name: "api error with get request",
params: v1dbrps.DeleteParams{
OrgParams: clients.OrgParams{
OrgName: "someOrg",
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPsID(gomock.Any(), "123").Return(api.ApiGetDBRPsIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().DeleteDBRPID(gomock.Any(), "123").Return(api.ApiDeleteDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsIDExecute(gomock.Any()).Return(api.DBRPGet{}, errApiTest)
},
expectedError: fmt.Errorf("failed to find DBRP mapping %q: %w", "123", errApiTest),
},
{
name: "api error with delete request",
params: v1dbrps.DeleteParams{
OrgParams: clients.OrgParams{
OrgName: "someOrg",
},
ID: "123",
},
registerExpectations: func(t *testing.T, DBRPsApi *mock.MockDBRPsApi) {
DBRPsApi.EXPECT().GetDBRPsID(gomock.Any(), "123").Return(api.ApiGetDBRPsIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().DeleteDBRPID(gomock.Any(), "123").Return(api.ApiDeleteDBRPIDRequest{ApiService: DBRPsApi})
DBRPsApi.EXPECT().GetDBRPsIDExecute(gomock.Any()).Return(api.DBRPGet{
Content: &api.DBRP{
Id: "123",
Database: "someDB",
BucketID: "456",
RetentionPolicy: "someRP",
Default: false,
OrgID: "1234123412341234",
},
}, nil)
DBRPsApi.EXPECT().DeleteDBRPIDExecute(gomock.Any()).Return(errApiTest)
},
expectedError: fmt.Errorf("failed to delete DBRP mapping %q: %w", "123", errApiTest),
},
}
for _, tc := range testCases {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
DBRPsApi := mock.NewMockDBRPsApi(ctrl)
if tc.registerExpectations != nil {
tc.registerExpectations(t, DBRPsApi)
}
stdout := bytes.Buffer{}
stdio := mock.NewMockStdIO(ctrl)
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
cli := v1dbrps.Client{CLI: clients.CLI{StdIO: stdio}, DBRPsApi: DBRPsApi}
err := cli.Delete(context.Background(), &tc.params)
require.Equal(t, tc.expectedError, err)
if tc.expectedError == nil {
testutils.MatchLines(t, append([]string{`ID\s+Database\s+Bucket\s+ID\s+Retention Policy\s+Default\s+Organization ID`}, tc.outLines...), strings.Split(stdout.String(), "\n"))
}
})
}
}

1
cmd/influx/v1_commands.go
View File

@ -8,7 +8,6 @@ func newV1SubCommand() *cli.Command {
Usage: "InfluxDB v1 management commands",
Subcommands: []*cli.Command{
newV1DBRPCmd(),
// etc
},
}
}

179
cmd/influx/v1_dbrp.go
View File

@ -1,19 +1,180 @@
package main
import "github.com/urfave/cli/v2"
import (
v1dbrps "github.com/influxdata/influx-cli/v2/clients/v1_dbrps"
"github.com/influxdata/influx-cli/v2/pkg/cli/middleware"
"github.com/urfave/cli/v2"
)
func newV1DBRPCmd() *cli.Command {
return &cli.Command{
Name: "dbrp",
Usage: "Commands to manage database and retention policy mappings for v1 APIs",
Name: "dbrp",
Usage: "Commands to manage database and retention policy mappings for v1 APIs",
Subcommands: []*cli.Command{
// newV1DBRPListCmd(),
// newV1DBRPCreateCmd(),
// newV1DBRPDeleteCmd(),
// newV1DBRPUpdateCmd(),
newV1DBRPListCmd(),
newV1DBRPCreateCmd(),
newV1DBRPDeleteCmd(),
newV1DBRPUpdateCmd(),
},
}
}
// commands will be implemented below, with business logic residing in their
// respective client package, like "v1_dbrp"
func newV1DBRPListCmd() *cli.Command {
var params v1dbrps.ListParams
flags := append(commonFlags(), getOrgFlags(&params.OrgParams)...)
return &cli.Command{
Name: "list",
Usage: "List database and retention policy mappings",
Aliases: []string{"find", "ls"},
Flags: append(
flags,
&cli.StringFlag{
Name: "bucket-id",
Usage: "Limit results to the matching bucket id",
Destination: &params.BucketID,
},
&cli.StringFlag{
Name: "db",
Usage: "Limit results to the matching database name",
Destination: &params.DB,
},
&cli.BoolFlag{
Name: "default",
Usage: "Limit results to default mappings",
Destination: &params.Default,
},
&cli.StringFlag{
Name: "id",
Usage: "Limit results to a single mapping",
Destination: &params.ID,
},
&cli.StringFlag{
Name: "rp",
Usage: "Limit results to the matching retention policy name",
Destination: &params.RP,
},
),
Before: middleware.WithBeforeFns(withCli(), withApi(true)),
Action: func(ctx *cli.Context) error {
api := getAPI(ctx)
client := v1dbrps.Client{
CLI: getCLI(ctx),
DBRPsApi: api.DBRPsApi,
}
return client.List(ctx.Context, &params)
},
}
}
func newV1DBRPCreateCmd() *cli.Command {
var params v1dbrps.CreateParams
flags := append(commonFlags(), getOrgFlags(&params.OrgParams)...)
return &cli.Command{
Name: "create",
Usage: "Create a database and retention policy mapping to an existing bucket",
Flags: append(
flags,
&cli.StringFlag{
Name: "bucket-id",
Usage: "The ID of the bucket to be mapped",
Destination: &params.BucketID,
Required: true,
},
&cli.StringFlag{
Name: "db",
Usage: "The name of the database",
Destination: &params.DB,
Required: true,
},
&cli.BoolFlag{
Name: "default",
Usage: "Identify this retention policy as the default for the database",
Destination: &params.Default,
},
&cli.StringFlag{
Name: "rp",
Usage: "The name of the retention policy",
Destination: &params.RP,
Required: true,
},
),
Before: middleware.WithBeforeFns(withCli(), withApi(true)),
Action: func(ctx *cli.Context) error {
api := getAPI(ctx)
client := v1dbrps.Client{
CLI: getCLI(ctx),
DBRPsApi: api.DBRPsApi,
OrganizationsApi: api.OrganizationsApi,
}
return client.Create(ctx.Context, &params)
},
}
}
func newV1DBRPDeleteCmd() *cli.Command {
var params v1dbrps.DeleteParams
flags := append(commonFlags(), getOrgFlags(&params.OrgParams)...)
return &cli.Command{
Name: "delete",
Usage: "Delete a database and retention policy mapping",
Flags: append(
flags,
&cli.StringFlag{
Name: "id",
Usage: "The ID of the mapping to delete",
Destination: &params.ID,
Required: true,
},
),
Before: middleware.WithBeforeFns(withCli(), withApi(true)),
Action: func(ctx *cli.Context) error {
api := getAPI(ctx)
client := v1dbrps.Client{
CLI: getCLI(ctx),
DBRPsApi: api.DBRPsApi,
}
return client.Delete(ctx.Context, &params)
},
}
}
func newV1DBRPUpdateCmd() *cli.Command {
var params v1dbrps.UpdateParams
flags := append(commonFlags(), getOrgFlags(&params.OrgParams)...)
return &cli.Command{
Name: "update",
Usage: "Update a database and retention policy mapping",
Flags: append(
flags,
&cli.StringFlag{
Name: "id",
Usage: "The ID of the mapping to update",
Destination: &params.ID,
Required: true,
},
&cli.BoolFlag{
Name: "default",
Usage: "Set this mapping's retention policy as the default for the mapping's database",
Destination: &params.Default,
},
&cli.StringFlag{
Name: "rp",
Usage: "The updated name of the retention policy",
Destination: &params.RP,
},
),
Before: middleware.WithBeforeFns(withCli(), withApi(true)),
Action: func(ctx *cli.Context) error {
api := getAPI(ctx)
client := v1dbrps.Client{
CLI: getCLI(ctx),
DBRPsApi: api.DBRPsApi,
}
return client.Update(ctx.Context, &params)
},
}
}

180
internal/mock/api_v1dbrps.gen.go Normal file
View File

@ -0,0 +1,180 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/influxdata/influx-cli/v2/api (interfaces: DBRPsApi)
// Package mock is a generated GoMock package.
package mock
import (
context "context"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
api "github.com/influxdata/influx-cli/v2/api"
)
// MockDBRPsApi is a mock of DBRPsApi interface.
type MockDBRPsApi struct {
ctrl *gomock.Controller
recorder *MockDBRPsApiMockRecorder
}
// MockDBRPsApiMockRecorder is the mock recorder for MockDBRPsApi.
type MockDBRPsApiMockRecorder struct {
mock *MockDBRPsApi
}
// NewMockDBRPsApi creates a new mock instance.
func NewMockDBRPsApi(ctrl *gomock.Controller) *MockDBRPsApi {
mock := &MockDBRPsApi{ctrl: ctrl}
mock.recorder = &MockDBRPsApiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDBRPsApi) EXPECT() *MockDBRPsApiMockRecorder {
return m.recorder
}
// DeleteDBRPID mocks base method.
func (m *MockDBRPsApi) DeleteDBRPID(arg0 context.Context, arg1 string) api.ApiDeleteDBRPIDRequest {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteDBRPID", arg0, arg1)
ret0, _ := ret[0].(api.ApiDeleteDBRPIDRequest)
return ret0
}
// DeleteDBRPID indicates an expected call of DeleteDBRPID.
func (mr *MockDBRPsApiMockRecorder) DeleteDBRPID(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBRPID", reflect.TypeOf((*MockDBRPsApi)(nil).DeleteDBRPID), arg0, arg1)
}
// DeleteDBRPIDExecute mocks base method.
func (m *MockDBRPsApi) DeleteDBRPIDExecute(arg0 api.ApiDeleteDBRPIDRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteDBRPIDExecute", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteDBRPIDExecute indicates an expected call of DeleteDBRPIDExecute.
func (mr *MockDBRPsApiMockRecorder) DeleteDBRPIDExecute(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBRPIDExecute", reflect.TypeOf((*MockDBRPsApi)(nil).DeleteDBRPIDExecute), arg0)
}
// GetDBRPs mocks base method.
func (m *MockDBRPsApi) GetDBRPs(arg0 context.Context) api.ApiGetDBRPsRequest {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetDBRPs", arg0)
ret0, _ := ret[0].(api.ApiGetDBRPsRequest)
return ret0
}
// GetDBRPs indicates an expected call of GetDBRPs.
func (mr *MockDBRPsApiMockRecorder) GetDBRPs(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDBRPs", reflect.TypeOf((*MockDBRPsApi)(nil).GetDBRPs), arg0)
}
// GetDBRPsExecute mocks base method.
func (m *MockDBRPsApi) GetDBRPsExecute(arg0 api.ApiGetDBRPsRequest) (api.DBRPs, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetDBRPsExecute", arg0)
ret0, _ := ret[0].(api.DBRPs)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetDBRPsExecute indicates an expected call of GetDBRPsExecute.
func (mr *MockDBRPsApiMockRecorder) GetDBRPsExecute(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDBRPsExecute", reflect.TypeOf((*MockDBRPsApi)(nil).GetDBRPsExecute), arg0)
}
// GetDBRPsID mocks base method.
func (m *MockDBRPsApi) GetDBRPsID(arg0 context.Context, arg1 string) api.ApiGetDBRPsIDRequest {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetDBRPsID", arg0, arg1)
ret0, _ := ret[0].(api.ApiGetDBRPsIDRequest)
return ret0
}
// GetDBRPsID indicates an expected call of GetDBRPsID.
func (mr *MockDBRPsApiMockRecorder) GetDBRPsID(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDBRPsID", reflect.TypeOf((*MockDBRPsApi)(nil).GetDBRPsID), arg0, arg1)
}
// GetDBRPsIDExecute mocks base method.
func (m *MockDBRPsApi) GetDBRPsIDExecute(arg0 api.ApiGetDBRPsIDRequest) (api.DBRPGet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetDBRPsIDExecute", arg0)
ret0, _ := ret[0].(api.DBRPGet)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetDBRPsIDExecute indicates an expected call of GetDBRPsIDExecute.
func (mr *MockDBRPsApiMockRecorder) GetDBRPsIDExecute(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDBRPsIDExecute", reflect.TypeOf((*MockDBRPsApi)(nil).GetDBRPsIDExecute), arg0)
}
// PatchDBRPID mocks base method.
func (m *MockDBRPsApi) PatchDBRPID(arg0 context.Context, arg1 string) api.ApiPatchDBRPIDRequest {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PatchDBRPID", arg0, arg1)
ret0, _ := ret[0].(api.ApiPatchDBRPIDRequest)
return ret0
}
// PatchDBRPID indicates an expected call of PatchDBRPID.
func (mr *MockDBRPsApiMockRecorder) PatchDBRPID(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDBRPID", reflect.TypeOf((*MockDBRPsApi)(nil).PatchDBRPID), arg0, arg1)
}
// PatchDBRPIDExecute mocks base method.
func (m *MockDBRPsApi) PatchDBRPIDExecute(arg0 api.ApiPatchDBRPIDRequest) (api.DBRPGet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PatchDBRPIDExecute", arg0)
ret0, _ := ret[0].(api.DBRPGet)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PatchDBRPIDExecute indicates an expected call of PatchDBRPIDExecute.
func (mr *MockDBRPsApiMockRecorder) PatchDBRPIDExecute(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDBRPIDExecute", reflect.TypeOf((*MockDBRPsApi)(nil).PatchDBRPIDExecute), arg0)
}
// PostDBRP mocks base method.
func (m *MockDBRPsApi) PostDBRP(arg0 context.Context) api.ApiPostDBRPRequest {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PostDBRP", arg0)
ret0, _ := ret[0].(api.ApiPostDBRPRequest)
return ret0
}
// PostDBRP indicates an expected call of PostDBRP.
func (mr *MockDBRPsApiMockRecorder) PostDBRP(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDBRP", reflect.TypeOf((*MockDBRPsApi)(nil).PostDBRP), arg0)
}
// PostDBRPExecute mocks base method.
func (m *MockDBRPsApi) PostDBRPExecute(arg0 api.ApiPostDBRPRequest) (api.DBRP, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PostDBRPExecute", arg0)
ret0, _ := ret[0].(api.DBRP)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PostDBRPExecute indicates an expected call of PostDBRPExecute.
func (mr *MockDBRPsApiMockRecorder) PostDBRPExecute(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDBRPExecute", reflect.TypeOf((*MockDBRPsApi)(nil).PostDBRPExecute), arg0)
}

1
internal/mock/gen.go
View File

@ -12,6 +12,7 @@ package mock
//go:generate go run github.com/golang/mock/mockgen -package mock -destination api_delete.gen.go github.com/influxdata/influx-cli/v2/api DeleteApi
//go:generate go run github.com/golang/mock/mockgen -package mock -destination api_backup.gen.go github.com/influxdata/influx-cli/v2/api BackupApi
//go:generate go run github.com/golang/mock/mockgen -package mock -destination api_secret.gen.go github.com/influxdata/influx-cli/v2/api SecretsApi
//go:generate go run github.com/golang/mock/mockgen -package mock -destination api_v1dbrps.gen.go github.com/influxdata/influx-cli/v2/api DBRPsApi
// Other mocks
//go:generate go run github.com/golang/mock/mockgen -package mock -destination config.gen.go -mock_names Service=MockConfigService github.com/influxdata/influx-cli/v2/config Service