github.com/gophercloud/gophercloud@v1.11.0/openstack/networking/v2/extensions/qos/rules/requests.go (about)

     1  package rules
     2  
     3  import (
     4  	"github.com/gophercloud/gophercloud"
     5  	"github.com/gophercloud/gophercloud/pagination"
     6  )
     7  
     8  // ListOptsBuilder allows extensions to add additional parameters to the
     9  // List request.
    10  type BandwidthLimitRulesListOptsBuilder interface {
    11  	ToBandwidthLimitRulesListQuery() (string, error)
    12  }
    13  
    14  // ListOpts allows the filtering and sorting of paginated collections through
    15  // the Neutron API. Filtering is achieved by passing in struct field values
    16  // that map to the BandwidthLimitRules attributes you want to see returned.
    17  // SortKey allows you to sort by a particular BandwidthLimitRule attribute.
    18  // SortDir sets the direction, and is either `asc' or `desc'.
    19  // Marker and Limit are used for the pagination.
    20  type BandwidthLimitRulesListOpts struct {
    21  	ID           string `q:"id"`
    22  	TenantID     string `q:"tenant_id"`
    23  	MaxKBps      int    `q:"max_kbps"`
    24  	MaxBurstKBps int    `q:"max_burst_kbps"`
    25  	Direction    string `q:"direction"`
    26  	Limit        int    `q:"limit"`
    27  	Marker       string `q:"marker"`
    28  	SortKey      string `q:"sort_key"`
    29  	SortDir      string `q:"sort_dir"`
    30  	Tags         string `q:"tags"`
    31  	TagsAny      string `q:"tags-any"`
    32  	NotTags      string `q:"not-tags"`
    33  	NotTagsAny   string `q:"not-tags-any"`
    34  }
    35  
    36  // ToBandwidthLimitRulesListQuery formats a ListOpts into a query string.
    37  func (opts BandwidthLimitRulesListOpts) ToBandwidthLimitRulesListQuery() (string, error) {
    38  	q, err := gophercloud.BuildQueryString(opts)
    39  	return q.String(), err
    40  }
    41  
    42  // ListBandwidthLimitRules returns a Pager which allows you to iterate over a collection of
    43  // BandwidthLimitRules. It accepts a ListOpts struct, which allows you to filter and sort
    44  // the returned collection for greater efficiency.
    45  func ListBandwidthLimitRules(c *gophercloud.ServiceClient, policyID string, opts BandwidthLimitRulesListOptsBuilder) pagination.Pager {
    46  	url := listBandwidthLimitRulesURL(c, policyID)
    47  	if opts != nil {
    48  		query, err := opts.ToBandwidthLimitRulesListQuery()
    49  		if err != nil {
    50  			return pagination.Pager{Err: err}
    51  		}
    52  		url += query
    53  	}
    54  	return pagination.NewPager(c, url, func(r pagination.PageResult) pagination.Page {
    55  		return BandwidthLimitRulePage{pagination.LinkedPageBase{PageResult: r}}
    56  
    57  	})
    58  }
    59  
    60  // GetBandwidthLimitRule retrieves a specific BandwidthLimitRule based on its ID.
    61  func GetBandwidthLimitRule(c *gophercloud.ServiceClient, policyID, ruleID string) (r GetBandwidthLimitRuleResult) {
    62  	resp, err := c.Get(getBandwidthLimitRuleURL(c, policyID, ruleID), &r.Body, nil)
    63  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
    64  	return
    65  }
    66  
    67  // CreateBandwidthLimitRuleOptsBuilder allows to add additional parameters to the
    68  // CreateBandwidthLimitRule request.
    69  type CreateBandwidthLimitRuleOptsBuilder interface {
    70  	ToBandwidthLimitRuleCreateMap() (map[string]interface{}, error)
    71  }
    72  
    73  // CreateBandwidthLimitRuleOpts specifies parameters of a new BandwidthLimitRule.
    74  type CreateBandwidthLimitRuleOpts struct {
    75  	// MaxKBps is a maximum kilobits per second. It's a required parameter.
    76  	MaxKBps int `json:"max_kbps"`
    77  
    78  	// MaxBurstKBps is a maximum burst size in kilobits.
    79  	MaxBurstKBps int `json:"max_burst_kbps,omitempty"`
    80  
    81  	// Direction represents the direction of traffic.
    82  	Direction string `json:"direction,omitempty"`
    83  }
    84  
    85  // ToBandwidthLimitRuleCreateMap constructs a request body from CreateBandwidthLimitRuleOpts.
    86  func (opts CreateBandwidthLimitRuleOpts) ToBandwidthLimitRuleCreateMap() (map[string]interface{}, error) {
    87  	return gophercloud.BuildRequestBody(opts, "bandwidth_limit_rule")
    88  }
    89  
    90  // CreateBandwidthLimitRule requests the creation of a new BandwidthLimitRule on the server.
    91  func CreateBandwidthLimitRule(client *gophercloud.ServiceClient, policyID string, opts CreateBandwidthLimitRuleOptsBuilder) (r CreateBandwidthLimitRuleResult) {
    92  	b, err := opts.ToBandwidthLimitRuleCreateMap()
    93  	if err != nil {
    94  		r.Err = err
    95  		return
    96  	}
    97  	resp, err := client.Post(createBandwidthLimitRuleURL(client, policyID), b, &r.Body, &gophercloud.RequestOpts{
    98  		OkCodes: []int{201},
    99  	})
   100  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   101  	return
   102  }
   103  
   104  // UpdateBandwidthLimitRuleOptsBuilder allows to add additional parameters to the
   105  // UpdateBandwidthLimitRule request.
   106  type UpdateBandwidthLimitRuleOptsBuilder interface {
   107  	ToBandwidthLimitRuleUpdateMap() (map[string]interface{}, error)
   108  }
   109  
   110  // UpdateBandwidthLimitRuleOpts specifies parameters for the Update call.
   111  type UpdateBandwidthLimitRuleOpts struct {
   112  	// MaxKBps is a maximum kilobits per second.
   113  	MaxKBps *int `json:"max_kbps,omitempty"`
   114  
   115  	// MaxBurstKBps is a maximum burst size in kilobits.
   116  	MaxBurstKBps *int `json:"max_burst_kbps,omitempty"`
   117  
   118  	// Direction represents the direction of traffic.
   119  	Direction string `json:"direction,omitempty"`
   120  }
   121  
   122  // ToBandwidthLimitRuleUpdateMap constructs a request body from UpdateBandwidthLimitRuleOpts.
   123  func (opts UpdateBandwidthLimitRuleOpts) ToBandwidthLimitRuleUpdateMap() (map[string]interface{}, error) {
   124  	return gophercloud.BuildRequestBody(opts, "bandwidth_limit_rule")
   125  }
   126  
   127  // UpdateBandwidthLimitRule requests the creation of a new BandwidthLimitRule on the server.
   128  func UpdateBandwidthLimitRule(client *gophercloud.ServiceClient, policyID, ruleID string, opts UpdateBandwidthLimitRuleOptsBuilder) (r UpdateBandwidthLimitRuleResult) {
   129  	b, err := opts.ToBandwidthLimitRuleUpdateMap()
   130  	if err != nil {
   131  		r.Err = err
   132  		return
   133  	}
   134  	resp, err := client.Put(updateBandwidthLimitRuleURL(client, policyID, ruleID), b, &r.Body, &gophercloud.RequestOpts{
   135  		OkCodes: []int{200},
   136  	})
   137  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   138  	return
   139  }
   140  
   141  // Delete accepts policy and rule ID and deletes the BandwidthLimitRule associated with them.
   142  func DeleteBandwidthLimitRule(c *gophercloud.ServiceClient, policyID, ruleID string) (r DeleteBandwidthLimitRuleResult) {
   143  	resp, err := c.Delete(deleteBandwidthLimitRuleURL(c, policyID, ruleID), nil)
   144  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   145  	return
   146  }
   147  
   148  // DSCPMarkingRulesListOptsBuilder allows extensions to add additional parameters to the
   149  // List request.
   150  type DSCPMarkingRulesListOptsBuilder interface {
   151  	ToDSCPMarkingRulesListQuery() (string, error)
   152  }
   153  
   154  // DSCPMarkingRulesListOpts allows the filtering and sorting of paginated collections through
   155  // the Neutron API. Filtering is achieved by passing in struct field values
   156  // that map to the DSCPMarking attributes you want to see returned.
   157  // SortKey allows you to sort by a particular DSCPMarkingRule attribute.
   158  // SortDir sets the direction, and is either `asc' or `desc'.
   159  // Marker and Limit are used for the pagination.
   160  type DSCPMarkingRulesListOpts struct {
   161  	ID         string `q:"id"`
   162  	TenantID   string `q:"tenant_id"`
   163  	DSCPMark   int    `q:"dscp_mark"`
   164  	Limit      int    `q:"limit"`
   165  	Marker     string `q:"marker"`
   166  	SortKey    string `q:"sort_key"`
   167  	SortDir    string `q:"sort_dir"`
   168  	Tags       string `q:"tags"`
   169  	TagsAny    string `q:"tags-any"`
   170  	NotTags    string `q:"not-tags"`
   171  	NotTagsAny string `q:"not-tags-any"`
   172  }
   173  
   174  // ToDSCPMarkingRulesListQuery formats a ListOpts into a query string.
   175  func (opts DSCPMarkingRulesListOpts) ToDSCPMarkingRulesListQuery() (string, error) {
   176  	q, err := gophercloud.BuildQueryString(opts)
   177  	return q.String(), err
   178  }
   179  
   180  // ListDSCPMarkingRules returns a Pager which allows you to iterate over a collection of
   181  // DSCPMarkingRules. It accepts a ListOpts struct, which allows you to filter and sort
   182  // the returned collection for greater efficiency.
   183  func ListDSCPMarkingRules(c *gophercloud.ServiceClient, policyID string, opts DSCPMarkingRulesListOptsBuilder) pagination.Pager {
   184  	url := listDSCPMarkingRulesURL(c, policyID)
   185  	if opts != nil {
   186  		query, err := opts.ToDSCPMarkingRulesListQuery()
   187  		if err != nil {
   188  			return pagination.Pager{Err: err}
   189  		}
   190  		url += query
   191  	}
   192  	return pagination.NewPager(c, url, func(r pagination.PageResult) pagination.Page {
   193  		return DSCPMarkingRulePage{pagination.LinkedPageBase{PageResult: r}}
   194  
   195  	})
   196  }
   197  
   198  // GetDSCPMarkingRule retrieves a specific DSCPMarkingRule based on its ID.
   199  func GetDSCPMarkingRule(c *gophercloud.ServiceClient, policyID, ruleID string) (r GetDSCPMarkingRuleResult) {
   200  	resp, err := c.Get(getDSCPMarkingRuleURL(c, policyID, ruleID), &r.Body, nil)
   201  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   202  	return
   203  }
   204  
   205  // CreateDSCPMarkingRuleOptsBuilder allows to add additional parameters to the
   206  // CreateDSCPMarkingRule request.
   207  type CreateDSCPMarkingRuleOptsBuilder interface {
   208  	ToDSCPMarkingRuleCreateMap() (map[string]interface{}, error)
   209  }
   210  
   211  // CreateDSCPMarkingRuleOpts specifies parameters of a new DSCPMarkingRule.
   212  type CreateDSCPMarkingRuleOpts struct {
   213  	// DSCPMark contains DSCP mark value.
   214  	DSCPMark int `json:"dscp_mark"`
   215  }
   216  
   217  // ToDSCPMarkingRuleCreateMap constructs a request body from CreateDSCPMarkingRuleOpts.
   218  func (opts CreateDSCPMarkingRuleOpts) ToDSCPMarkingRuleCreateMap() (map[string]interface{}, error) {
   219  	return gophercloud.BuildRequestBody(opts, "dscp_marking_rule")
   220  }
   221  
   222  // CreateDSCPMarkingRule requests the creation of a new DSCPMarkingRule on the server.
   223  func CreateDSCPMarkingRule(client *gophercloud.ServiceClient, policyID string, opts CreateDSCPMarkingRuleOptsBuilder) (r CreateDSCPMarkingRuleResult) {
   224  	b, err := opts.ToDSCPMarkingRuleCreateMap()
   225  	if err != nil {
   226  		r.Err = err
   227  		return
   228  	}
   229  	resp, err := client.Post(createDSCPMarkingRuleURL(client, policyID), b, &r.Body, &gophercloud.RequestOpts{
   230  		OkCodes: []int{201},
   231  	})
   232  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   233  	return
   234  }
   235  
   236  // UpdateDSCPMarkingRuleOptsBuilder allows to add additional parameters to the
   237  // UpdateDSCPMarkingRule request.
   238  type UpdateDSCPMarkingRuleOptsBuilder interface {
   239  	ToDSCPMarkingRuleUpdateMap() (map[string]interface{}, error)
   240  }
   241  
   242  // UpdateDSCPMarkingRuleOpts specifies parameters for the Update call.
   243  type UpdateDSCPMarkingRuleOpts struct {
   244  	// DSCPMark contains DSCP mark value.
   245  	DSCPMark *int `json:"dscp_mark,omitempty"`
   246  }
   247  
   248  // ToDSCPMarkingRuleUpdateMap constructs a request body from UpdateDSCPMarkingRuleOpts.
   249  func (opts UpdateDSCPMarkingRuleOpts) ToDSCPMarkingRuleUpdateMap() (map[string]interface{}, error) {
   250  	return gophercloud.BuildRequestBody(opts, "dscp_marking_rule")
   251  }
   252  
   253  // UpdateDSCPMarkingRule requests the creation of a new DSCPMarkingRule on the server.
   254  func UpdateDSCPMarkingRule(client *gophercloud.ServiceClient, policyID, ruleID string, opts UpdateDSCPMarkingRuleOptsBuilder) (r UpdateDSCPMarkingRuleResult) {
   255  	b, err := opts.ToDSCPMarkingRuleUpdateMap()
   256  	if err != nil {
   257  		r.Err = err
   258  		return
   259  	}
   260  	resp, err := client.Put(updateDSCPMarkingRuleURL(client, policyID, ruleID), b, &r.Body, &gophercloud.RequestOpts{
   261  		OkCodes: []int{200},
   262  	})
   263  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   264  	return
   265  }
   266  
   267  // DeleteDSCPMarkingRule accepts policy and rule ID and deletes the DSCPMarkingRule associated with them.
   268  func DeleteDSCPMarkingRule(c *gophercloud.ServiceClient, policyID, ruleID string) (r DeleteDSCPMarkingRuleResult) {
   269  	resp, err := c.Delete(deleteDSCPMarkingRuleURL(c, policyID, ruleID), nil)
   270  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   271  	return
   272  }
   273  
   274  // ListOptsBuilder allows extensions to add additional parameters to the
   275  // List request.
   276  type MinimumBandwidthRulesListOptsBuilder interface {
   277  	ToMinimumBandwidthRulesListQuery() (string, error)
   278  }
   279  
   280  // ListOpts allows the filtering and sorting of paginated collections through
   281  // the Neutron API. Filtering is achieved by passing in struct field values
   282  // that map to the MinimumBandwidthRules attributes you want to see returned.
   283  // SortKey allows you to sort by a particular MinimumBandwidthRule attribute.
   284  // SortDir sets the direction, and is either `asc' or `desc'.
   285  // Marker and Limit are used for the pagination.
   286  type MinimumBandwidthRulesListOpts struct {
   287  	ID         string `q:"id"`
   288  	TenantID   string `q:"tenant_id"`
   289  	MinKBps    int    `q:"min_kbps"`
   290  	Direction  string `q:"direction"`
   291  	Limit      int    `q:"limit"`
   292  	Marker     string `q:"marker"`
   293  	SortKey    string `q:"sort_key"`
   294  	SortDir    string `q:"sort_dir"`
   295  	Tags       string `q:"tags"`
   296  	TagsAny    string `q:"tags-any"`
   297  	NotTags    string `q:"not-tags"`
   298  	NotTagsAny string `q:"not-tags-any"`
   299  }
   300  
   301  // ToMinimumBandwidthRulesListQuery formats a ListOpts into a query string.
   302  func (opts MinimumBandwidthRulesListOpts) ToMinimumBandwidthRulesListQuery() (string, error) {
   303  	q, err := gophercloud.BuildQueryString(opts)
   304  	return q.String(), err
   305  }
   306  
   307  // ListMinimumBandwidthRules returns a Pager which allows you to iterate over a collection of
   308  // MinimumBandwidthRules. It accepts a ListOpts struct, which allows you to filter and sort
   309  // the returned collection for greater efficiency.
   310  func ListMinimumBandwidthRules(c *gophercloud.ServiceClient, policyID string, opts MinimumBandwidthRulesListOptsBuilder) pagination.Pager {
   311  	url := listMinimumBandwidthRulesURL(c, policyID)
   312  	if opts != nil {
   313  		query, err := opts.ToMinimumBandwidthRulesListQuery()
   314  		if err != nil {
   315  			return pagination.Pager{Err: err}
   316  		}
   317  		url += query
   318  	}
   319  	return pagination.NewPager(c, url, func(r pagination.PageResult) pagination.Page {
   320  		return MinimumBandwidthRulePage{pagination.LinkedPageBase{PageResult: r}}
   321  
   322  	})
   323  }
   324  
   325  // GetMinimumBandwidthRule retrieves a specific MinimumBandwidthRule based on its ID.
   326  func GetMinimumBandwidthRule(c *gophercloud.ServiceClient, policyID, ruleID string) (r GetMinimumBandwidthRuleResult) {
   327  	resp, err := c.Get(getMinimumBandwidthRuleURL(c, policyID, ruleID), &r.Body, nil)
   328  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   329  	return
   330  }
   331  
   332  // CreateMinimumBandwidthRuleOptsBuilder allows to add additional parameters to the
   333  // CreateMinimumBandwidthRule request.
   334  type CreateMinimumBandwidthRuleOptsBuilder interface {
   335  	ToMinimumBandwidthRuleCreateMap() (map[string]interface{}, error)
   336  }
   337  
   338  // CreateMinimumBandwidthRuleOpts specifies parameters of a new MinimumBandwidthRule.
   339  type CreateMinimumBandwidthRuleOpts struct {
   340  	// MaxKBps is a minimum kilobits per second. It's a required parameter.
   341  	MinKBps int `json:"min_kbps"`
   342  
   343  	// Direction represents the direction of traffic.
   344  	Direction string `json:"direction,omitempty"`
   345  }
   346  
   347  // ToMinimumBandwidthRuleCreateMap constructs a request body from CreateMinimumBandwidthRuleOpts.
   348  func (opts CreateMinimumBandwidthRuleOpts) ToMinimumBandwidthRuleCreateMap() (map[string]interface{}, error) {
   349  	return gophercloud.BuildRequestBody(opts, "minimum_bandwidth_rule")
   350  }
   351  
   352  // CreateMinimumBandwidthRule requests the creation of a new MinimumBandwidthRule on the server.
   353  func CreateMinimumBandwidthRule(client *gophercloud.ServiceClient, policyID string, opts CreateMinimumBandwidthRuleOptsBuilder) (r CreateMinimumBandwidthRuleResult) {
   354  	b, err := opts.ToMinimumBandwidthRuleCreateMap()
   355  	if err != nil {
   356  		r.Err = err
   357  		return
   358  	}
   359  	resp, err := client.Post(createMinimumBandwidthRuleURL(client, policyID), b, &r.Body, &gophercloud.RequestOpts{
   360  		OkCodes: []int{201},
   361  	})
   362  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   363  	return
   364  }
   365  
   366  // UpdateMinimumBandwidthRuleOptsBuilder allows to add additional parameters to the
   367  // UpdateMinimumBandwidthRule request.
   368  type UpdateMinimumBandwidthRuleOptsBuilder interface {
   369  	ToMinimumBandwidthRuleUpdateMap() (map[string]interface{}, error)
   370  }
   371  
   372  // UpdateMinimumBandwidthRuleOpts specifies parameters for the Update call.
   373  type UpdateMinimumBandwidthRuleOpts struct {
   374  	// MaxKBps is a minimum kilobits per second. It's a required parameter.
   375  	MinKBps *int `json:"min_kbps,omitempty"`
   376  
   377  	// Direction represents the direction of traffic.
   378  	Direction string `json:"direction,omitempty"`
   379  }
   380  
   381  // ToMinimumBandwidthRuleUpdateMap constructs a request body from UpdateMinimumBandwidthRuleOpts.
   382  func (opts UpdateMinimumBandwidthRuleOpts) ToMinimumBandwidthRuleUpdateMap() (map[string]interface{}, error) {
   383  	return gophercloud.BuildRequestBody(opts, "minimum_bandwidth_rule")
   384  }
   385  
   386  // UpdateMinimumBandwidthRule requests the creation of a new MinimumBandwidthRule on the server.
   387  func UpdateMinimumBandwidthRule(client *gophercloud.ServiceClient, policyID, ruleID string, opts UpdateMinimumBandwidthRuleOptsBuilder) (r UpdateMinimumBandwidthRuleResult) {
   388  	b, err := opts.ToMinimumBandwidthRuleUpdateMap()
   389  	if err != nil {
   390  		r.Err = err
   391  		return
   392  	}
   393  	resp, err := client.Put(updateMinimumBandwidthRuleURL(client, policyID, ruleID), b, &r.Body, &gophercloud.RequestOpts{
   394  		OkCodes: []int{200},
   395  	})
   396  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   397  	return
   398  }
   399  
   400  // DeleteMinimumBandwidthRule accepts policy and rule ID and deletes the MinimumBandwidthRule associated with them.
   401  func DeleteMinimumBandwidthRule(c *gophercloud.ServiceClient, policyID, ruleID string) (r DeleteMinimumBandwidthRuleResult) {
   402  	resp, err := c.Delete(deleteMinimumBandwidthRuleURL(c, policyID, ruleID), nil)
   403  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   404  	return
   405  }