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 }