packet_generators

package
v0.0.0-...-8fe3866 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 30, 2023 License: Apache-2.0 Imports: 13 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BulkCreatePacketGeneratorsBody 

type BulkCreatePacketGeneratorsBody struct {

	// List of packet generators
	// Required: true
	// Min Items: 1
	Items []*models.PacketGenerator `json:"items"`
}

BulkCreatePacketGeneratorsBody BulkCreatePacketGeneratorsRequest // // Parameters for the bulk create operation swagger:model BulkCreatePacketGeneratorsBody

func (*BulkCreatePacketGeneratorsBody) ContextValidate 

func (o *BulkCreatePacketGeneratorsBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this bulk create packet generators body based on the context it is used

func (*BulkCreatePacketGeneratorsBody) MarshalBinary 

func (o *BulkCreatePacketGeneratorsBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BulkCreatePacketGeneratorsBody) UnmarshalBinary 

func (o *BulkCreatePacketGeneratorsBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BulkCreatePacketGeneratorsBody) Validate 

func (o *BulkCreatePacketGeneratorsBody) Validate(formats strfmt.Registry) error

Validate validates this bulk create packet generators body

type BulkCreatePacketGeneratorsOK 

type BulkCreatePacketGeneratorsOK struct {
	Payload *BulkCreatePacketGeneratorsOKBody
}
BulkCreatePacketGeneratorsOK describes a response with status code 200, with default header values.

Success

func NewBulkCreatePacketGeneratorsOK 

func NewBulkCreatePacketGeneratorsOK() *BulkCreatePacketGeneratorsOK

NewBulkCreatePacketGeneratorsOK creates a BulkCreatePacketGeneratorsOK with default headers values

func (*BulkCreatePacketGeneratorsOK) Error 

func (o *BulkCreatePacketGeneratorsOK) Error() string

func (*BulkCreatePacketGeneratorsOK) GetPayload 

func (o *BulkCreatePacketGeneratorsOK) GetPayload() *BulkCreatePacketGeneratorsOKBody

type BulkCreatePacketGeneratorsOKBody 

type BulkCreatePacketGeneratorsOKBody struct {

	// List of packet generators
	// Required: true
	// Min Items: 1
	Items []*models.PacketGenerator `json:"items"`
}

BulkCreatePacketGeneratorsOKBody BulkCreatePacketGeneratorsResponse swagger:model BulkCreatePacketGeneratorsOKBody

func (*BulkCreatePacketGeneratorsOKBody) ContextValidate 

func (o *BulkCreatePacketGeneratorsOKBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this bulk create packet generators o k body based on the context it is used

func (*BulkCreatePacketGeneratorsOKBody) MarshalBinary 

func (o *BulkCreatePacketGeneratorsOKBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BulkCreatePacketGeneratorsOKBody) UnmarshalBinary 

func (o *BulkCreatePacketGeneratorsOKBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BulkCreatePacketGeneratorsOKBody) Validate 

func (o *BulkCreatePacketGeneratorsOKBody) Validate(formats strfmt.Registry) error

Validate validates this bulk create packet generators o k body

type BulkCreatePacketGeneratorsParams 

type BulkCreatePacketGeneratorsParams struct {

	/* Create.

	   Bulk creation
	*/
	Create BulkCreatePacketGeneratorsBody

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

BulkCreatePacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the bulk create packet generators operation.

Typically these are written to a http.Request.

func NewBulkCreatePacketGeneratorsParams 

func NewBulkCreatePacketGeneratorsParams() *BulkCreatePacketGeneratorsParams

NewBulkCreatePacketGeneratorsParams creates a new BulkCreatePacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewBulkCreatePacketGeneratorsParamsWithContext 

func NewBulkCreatePacketGeneratorsParamsWithContext(ctx context.Context) *BulkCreatePacketGeneratorsParams

NewBulkCreatePacketGeneratorsParamsWithContext creates a new BulkCreatePacketGeneratorsParams object with the ability to set a context for a request.

func NewBulkCreatePacketGeneratorsParamsWithHTTPClient 

func NewBulkCreatePacketGeneratorsParamsWithHTTPClient(client *http.Client) *BulkCreatePacketGeneratorsParams

NewBulkCreatePacketGeneratorsParamsWithHTTPClient creates a new BulkCreatePacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewBulkCreatePacketGeneratorsParamsWithTimeout 

func NewBulkCreatePacketGeneratorsParamsWithTimeout(timeout time.Duration) *BulkCreatePacketGeneratorsParams

NewBulkCreatePacketGeneratorsParamsWithTimeout creates a new BulkCreatePacketGeneratorsParams object with the ability to set a timeout on a request.

func (*BulkCreatePacketGeneratorsParams) SetContext 

func (o *BulkCreatePacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) SetCreate 

func (o *BulkCreatePacketGeneratorsParams) SetCreate(create BulkCreatePacketGeneratorsBody)

SetCreate adds the create to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) SetDefaults 

func (o *BulkCreatePacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the bulk create packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkCreatePacketGeneratorsParams) SetHTTPClient 

func (o *BulkCreatePacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) SetTimeout 

func (o *BulkCreatePacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) WithContext 

func (o *BulkCreatePacketGeneratorsParams) WithContext(ctx context.Context) *BulkCreatePacketGeneratorsParams

WithContext adds the context to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) WithCreate 

func (o *BulkCreatePacketGeneratorsParams) WithCreate(create BulkCreatePacketGeneratorsBody) *BulkCreatePacketGeneratorsParams

WithCreate adds the create to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) WithDefaults 

func (o *BulkCreatePacketGeneratorsParams) WithDefaults() *BulkCreatePacketGeneratorsParams

WithDefaults hydrates default values in the bulk create packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkCreatePacketGeneratorsParams) WithHTTPClient 

func (o *BulkCreatePacketGeneratorsParams) WithHTTPClient(client *http.Client) *BulkCreatePacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) WithTimeout 

func (o *BulkCreatePacketGeneratorsParams) WithTimeout(timeout time.Duration) *BulkCreatePacketGeneratorsParams

WithTimeout adds the timeout to the bulk create packet generators params

func (*BulkCreatePacketGeneratorsParams) WriteToRequest 

func (o *BulkCreatePacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type BulkCreatePacketGeneratorsReader 

type BulkCreatePacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

BulkCreatePacketGeneratorsReader is a Reader for the BulkCreatePacketGenerators structure.

func (*BulkCreatePacketGeneratorsReader) ReadResponse 

func (o *BulkCreatePacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type BulkDeletePacketGeneratorsBody 

type BulkDeletePacketGeneratorsBody struct {

	// List of packet generators
	// Required: true
	// Min Items: 1
	Ids []string `json:"ids"`
}

BulkDeletePacketGeneratorsBody BulkDeletePacketGeneratorsRequest // // Parameters for the bulk delete operation swagger:model BulkDeletePacketGeneratorsBody

func (*BulkDeletePacketGeneratorsBody) ContextValidate 

func (o *BulkDeletePacketGeneratorsBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this bulk delete packet generators body based on context it is used

func (*BulkDeletePacketGeneratorsBody) MarshalBinary 

func (o *BulkDeletePacketGeneratorsBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BulkDeletePacketGeneratorsBody) UnmarshalBinary 

func (o *BulkDeletePacketGeneratorsBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BulkDeletePacketGeneratorsBody) Validate 

func (o *BulkDeletePacketGeneratorsBody) Validate(formats strfmt.Registry) error

Validate validates this bulk delete packet generators body

type BulkDeletePacketGeneratorsNoContent 

type BulkDeletePacketGeneratorsNoContent struct {
}
BulkDeletePacketGeneratorsNoContent describes a response with status code 204, with default header values.

No Content

func NewBulkDeletePacketGeneratorsNoContent 

func NewBulkDeletePacketGeneratorsNoContent() *BulkDeletePacketGeneratorsNoContent

NewBulkDeletePacketGeneratorsNoContent creates a BulkDeletePacketGeneratorsNoContent with default headers values

func (*BulkDeletePacketGeneratorsNoContent) Error 

func (o *BulkDeletePacketGeneratorsNoContent) Error() string

type BulkDeletePacketGeneratorsParams 

type BulkDeletePacketGeneratorsParams struct {

	/* Delete.

	   Bulk delete
	*/
	Delete BulkDeletePacketGeneratorsBody

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

BulkDeletePacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the bulk delete packet generators operation.

Typically these are written to a http.Request.

func NewBulkDeletePacketGeneratorsParams 

func NewBulkDeletePacketGeneratorsParams() *BulkDeletePacketGeneratorsParams

NewBulkDeletePacketGeneratorsParams creates a new BulkDeletePacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewBulkDeletePacketGeneratorsParamsWithContext 

func NewBulkDeletePacketGeneratorsParamsWithContext(ctx context.Context) *BulkDeletePacketGeneratorsParams

NewBulkDeletePacketGeneratorsParamsWithContext creates a new BulkDeletePacketGeneratorsParams object with the ability to set a context for a request.

func NewBulkDeletePacketGeneratorsParamsWithHTTPClient 

func NewBulkDeletePacketGeneratorsParamsWithHTTPClient(client *http.Client) *BulkDeletePacketGeneratorsParams

NewBulkDeletePacketGeneratorsParamsWithHTTPClient creates a new BulkDeletePacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewBulkDeletePacketGeneratorsParamsWithTimeout 

func NewBulkDeletePacketGeneratorsParamsWithTimeout(timeout time.Duration) *BulkDeletePacketGeneratorsParams

NewBulkDeletePacketGeneratorsParamsWithTimeout creates a new BulkDeletePacketGeneratorsParams object with the ability to set a timeout on a request.

func (*BulkDeletePacketGeneratorsParams) SetContext 

func (o *BulkDeletePacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) SetDefaults 

func (o *BulkDeletePacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the bulk delete packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkDeletePacketGeneratorsParams) SetDelete 

func (o *BulkDeletePacketGeneratorsParams) SetDelete(delete BulkDeletePacketGeneratorsBody)

SetDelete adds the delete to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) SetHTTPClient 

func (o *BulkDeletePacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) SetTimeout 

func (o *BulkDeletePacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) WithContext 

func (o *BulkDeletePacketGeneratorsParams) WithContext(ctx context.Context) *BulkDeletePacketGeneratorsParams

WithContext adds the context to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) WithDefaults 

func (o *BulkDeletePacketGeneratorsParams) WithDefaults() *BulkDeletePacketGeneratorsParams

WithDefaults hydrates default values in the bulk delete packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkDeletePacketGeneratorsParams) WithDelete 

func (o *BulkDeletePacketGeneratorsParams) WithDelete(delete BulkDeletePacketGeneratorsBody) *BulkDeletePacketGeneratorsParams

WithDelete adds the delete to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) WithHTTPClient 

func (o *BulkDeletePacketGeneratorsParams) WithHTTPClient(client *http.Client) *BulkDeletePacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) WithTimeout 

func (o *BulkDeletePacketGeneratorsParams) WithTimeout(timeout time.Duration) *BulkDeletePacketGeneratorsParams

WithTimeout adds the timeout to the bulk delete packet generators params

func (*BulkDeletePacketGeneratorsParams) WriteToRequest 

func (o *BulkDeletePacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type BulkDeletePacketGeneratorsReader 

type BulkDeletePacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

BulkDeletePacketGeneratorsReader is a Reader for the BulkDeletePacketGenerators structure.

func (*BulkDeletePacketGeneratorsReader) ReadResponse 

func (o *BulkDeletePacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type BulkStartPacketGeneratorsBody 

type BulkStartPacketGeneratorsBody struct {

	// List of packet generator identifiers
	// Required: true
	// Min Items: 1
	Ids []string `json:"ids"`
}

BulkStartPacketGeneratorsBody BulkStartPacketGeneratorsRequest // // Parameters for the bulk start operation swagger:model BulkStartPacketGeneratorsBody

func (*BulkStartPacketGeneratorsBody) ContextValidate 

func (o *BulkStartPacketGeneratorsBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this bulk start packet generators body based on context it is used

func (*BulkStartPacketGeneratorsBody) MarshalBinary 

func (o *BulkStartPacketGeneratorsBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BulkStartPacketGeneratorsBody) UnmarshalBinary 

func (o *BulkStartPacketGeneratorsBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BulkStartPacketGeneratorsBody) Validate 

func (o *BulkStartPacketGeneratorsBody) Validate(formats strfmt.Registry) error

Validate validates this bulk start packet generators body

type BulkStartPacketGeneratorsOK 

type BulkStartPacketGeneratorsOK struct {
	Payload *BulkStartPacketGeneratorsOKBody
}
BulkStartPacketGeneratorsOK describes a response with status code 200, with default header values.

Success

func NewBulkStartPacketGeneratorsOK 

func NewBulkStartPacketGeneratorsOK() *BulkStartPacketGeneratorsOK

NewBulkStartPacketGeneratorsOK creates a BulkStartPacketGeneratorsOK with default headers values

func (*BulkStartPacketGeneratorsOK) Error 

func (o *BulkStartPacketGeneratorsOK) Error() string

func (*BulkStartPacketGeneratorsOK) GetPayload 

func (o *BulkStartPacketGeneratorsOK) GetPayload() *BulkStartPacketGeneratorsOKBody

type BulkStartPacketGeneratorsOKBody 

type BulkStartPacketGeneratorsOKBody struct {

	// List of packet generator results
	// Required: true
	// Min Items: 1
	Items []*models.PacketGeneratorResult `json:"items"`
}

BulkStartPacketGeneratorsOKBody BulkStartPacketGeneratorsResponse swagger:model BulkStartPacketGeneratorsOKBody

func (*BulkStartPacketGeneratorsOKBody) ContextValidate 

func (o *BulkStartPacketGeneratorsOKBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this bulk start packet generators o k body based on the context it is used

func (*BulkStartPacketGeneratorsOKBody) MarshalBinary 

func (o *BulkStartPacketGeneratorsOKBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BulkStartPacketGeneratorsOKBody) UnmarshalBinary 

func (o *BulkStartPacketGeneratorsOKBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BulkStartPacketGeneratorsOKBody) Validate 

func (o *BulkStartPacketGeneratorsOKBody) Validate(formats strfmt.Registry) error

Validate validates this bulk start packet generators o k body

type BulkStartPacketGeneratorsParams 

type BulkStartPacketGeneratorsParams struct {

	/* Start.

	   Bulk start
	*/
	Start BulkStartPacketGeneratorsBody

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

BulkStartPacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the bulk start packet generators operation.

Typically these are written to a http.Request.

func NewBulkStartPacketGeneratorsParams 

func NewBulkStartPacketGeneratorsParams() *BulkStartPacketGeneratorsParams

NewBulkStartPacketGeneratorsParams creates a new BulkStartPacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewBulkStartPacketGeneratorsParamsWithContext 

func NewBulkStartPacketGeneratorsParamsWithContext(ctx context.Context) *BulkStartPacketGeneratorsParams

NewBulkStartPacketGeneratorsParamsWithContext creates a new BulkStartPacketGeneratorsParams object with the ability to set a context for a request.

func NewBulkStartPacketGeneratorsParamsWithHTTPClient 

func NewBulkStartPacketGeneratorsParamsWithHTTPClient(client *http.Client) *BulkStartPacketGeneratorsParams

NewBulkStartPacketGeneratorsParamsWithHTTPClient creates a new BulkStartPacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewBulkStartPacketGeneratorsParamsWithTimeout 

func NewBulkStartPacketGeneratorsParamsWithTimeout(timeout time.Duration) *BulkStartPacketGeneratorsParams

NewBulkStartPacketGeneratorsParamsWithTimeout creates a new BulkStartPacketGeneratorsParams object with the ability to set a timeout on a request.

func (*BulkStartPacketGeneratorsParams) SetContext 

func (o *BulkStartPacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) SetDefaults 

func (o *BulkStartPacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the bulk start packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkStartPacketGeneratorsParams) SetHTTPClient 

func (o *BulkStartPacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) SetStart 

func (o *BulkStartPacketGeneratorsParams) SetStart(start BulkStartPacketGeneratorsBody)

SetStart adds the start to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) SetTimeout 

func (o *BulkStartPacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) WithContext 

func (o *BulkStartPacketGeneratorsParams) WithContext(ctx context.Context) *BulkStartPacketGeneratorsParams

WithContext adds the context to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) WithDefaults 

func (o *BulkStartPacketGeneratorsParams) WithDefaults() *BulkStartPacketGeneratorsParams

WithDefaults hydrates default values in the bulk start packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkStartPacketGeneratorsParams) WithHTTPClient 

func (o *BulkStartPacketGeneratorsParams) WithHTTPClient(client *http.Client) *BulkStartPacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) WithStart 

func (o *BulkStartPacketGeneratorsParams) WithStart(start BulkStartPacketGeneratorsBody) *BulkStartPacketGeneratorsParams

WithStart adds the start to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) WithTimeout 

func (o *BulkStartPacketGeneratorsParams) WithTimeout(timeout time.Duration) *BulkStartPacketGeneratorsParams

WithTimeout adds the timeout to the bulk start packet generators params

func (*BulkStartPacketGeneratorsParams) WriteToRequest 

func (o *BulkStartPacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type BulkStartPacketGeneratorsReader 

type BulkStartPacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

BulkStartPacketGeneratorsReader is a Reader for the BulkStartPacketGenerators structure.

func (*BulkStartPacketGeneratorsReader) ReadResponse 

func (o *BulkStartPacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type BulkStopPacketGeneratorsBody 

type BulkStopPacketGeneratorsBody struct {

	// List of packet generator identifiers
	// Required: true
	// Min Items: 1
	Ids []string `json:"ids"`
}

BulkStopPacketGeneratorsBody BulkStopPacketGeneratorsRequest // // Parameters for the bulk stop operation swagger:model BulkStopPacketGeneratorsBody

func (*BulkStopPacketGeneratorsBody) ContextValidate 

func (o *BulkStopPacketGeneratorsBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this bulk stop packet generators body based on context it is used

func (*BulkStopPacketGeneratorsBody) MarshalBinary 

func (o *BulkStopPacketGeneratorsBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*BulkStopPacketGeneratorsBody) UnmarshalBinary 

func (o *BulkStopPacketGeneratorsBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*BulkStopPacketGeneratorsBody) Validate 

func (o *BulkStopPacketGeneratorsBody) Validate(formats strfmt.Registry) error

Validate validates this bulk stop packet generators body

type BulkStopPacketGeneratorsNoContent 

type BulkStopPacketGeneratorsNoContent struct {
}
BulkStopPacketGeneratorsNoContent describes a response with status code 204, with default header values.

No Content

func NewBulkStopPacketGeneratorsNoContent 

func NewBulkStopPacketGeneratorsNoContent() *BulkStopPacketGeneratorsNoContent

NewBulkStopPacketGeneratorsNoContent creates a BulkStopPacketGeneratorsNoContent with default headers values

func (*BulkStopPacketGeneratorsNoContent) Error 

func (o *BulkStopPacketGeneratorsNoContent) Error() string

type BulkStopPacketGeneratorsParams 

type BulkStopPacketGeneratorsParams struct {

	/* Stop.

	   Bulk stop
	*/
	Stop BulkStopPacketGeneratorsBody

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

BulkStopPacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the bulk stop packet generators operation.

Typically these are written to a http.Request.

func NewBulkStopPacketGeneratorsParams 

func NewBulkStopPacketGeneratorsParams() *BulkStopPacketGeneratorsParams

NewBulkStopPacketGeneratorsParams creates a new BulkStopPacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewBulkStopPacketGeneratorsParamsWithContext 

func NewBulkStopPacketGeneratorsParamsWithContext(ctx context.Context) *BulkStopPacketGeneratorsParams

NewBulkStopPacketGeneratorsParamsWithContext creates a new BulkStopPacketGeneratorsParams object with the ability to set a context for a request.

func NewBulkStopPacketGeneratorsParamsWithHTTPClient 

func NewBulkStopPacketGeneratorsParamsWithHTTPClient(client *http.Client) *BulkStopPacketGeneratorsParams

NewBulkStopPacketGeneratorsParamsWithHTTPClient creates a new BulkStopPacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewBulkStopPacketGeneratorsParamsWithTimeout 

func NewBulkStopPacketGeneratorsParamsWithTimeout(timeout time.Duration) *BulkStopPacketGeneratorsParams

NewBulkStopPacketGeneratorsParamsWithTimeout creates a new BulkStopPacketGeneratorsParams object with the ability to set a timeout on a request.

func (*BulkStopPacketGeneratorsParams) SetContext 

func (o *BulkStopPacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) SetDefaults 

func (o *BulkStopPacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the bulk stop packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkStopPacketGeneratorsParams) SetHTTPClient 

func (o *BulkStopPacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) SetStop 

func (o *BulkStopPacketGeneratorsParams) SetStop(stop BulkStopPacketGeneratorsBody)

SetStop adds the stop to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) SetTimeout 

func (o *BulkStopPacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) WithContext 

func (o *BulkStopPacketGeneratorsParams) WithContext(ctx context.Context) *BulkStopPacketGeneratorsParams

WithContext adds the context to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) WithDefaults 

func (o *BulkStopPacketGeneratorsParams) WithDefaults() *BulkStopPacketGeneratorsParams

WithDefaults hydrates default values in the bulk stop packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*BulkStopPacketGeneratorsParams) WithHTTPClient 

func (o *BulkStopPacketGeneratorsParams) WithHTTPClient(client *http.Client) *BulkStopPacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) WithStop 

func (o *BulkStopPacketGeneratorsParams) WithStop(stop BulkStopPacketGeneratorsBody) *BulkStopPacketGeneratorsParams

WithStop adds the stop to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) WithTimeout 

func (o *BulkStopPacketGeneratorsParams) WithTimeout(timeout time.Duration) *BulkStopPacketGeneratorsParams

WithTimeout adds the timeout to the bulk stop packet generators params

func (*BulkStopPacketGeneratorsParams) WriteToRequest 

func (o *BulkStopPacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type BulkStopPacketGeneratorsReader 

type BulkStopPacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

BulkStopPacketGeneratorsReader is a Reader for the BulkStopPacketGenerators structure.

func (*BulkStopPacketGeneratorsReader) ReadResponse 

func (o *BulkStopPacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client for packet generators API

func (*Client) BulkCreatePacketGenerators 

func (a *Client) BulkCreatePacketGenerators(params *BulkCreatePacketGeneratorsParams, opts ...ClientOption) (*BulkCreatePacketGeneratorsOK, error)
BulkCreatePacketGenerators bulks create packet generators

Create multiple packet generators. Requests are processed in an

all-or-nothing manner, i.e. a single generator creation failure causes all generator creations for this request to fail.

func (*Client) BulkDeletePacketGenerators 

func (a *Client) BulkDeletePacketGenerators(params *BulkDeletePacketGeneratorsParams, opts ...ClientOption) (*BulkDeletePacketGeneratorsNoContent, error)
BulkDeletePacketGenerators bulks delete packet generators

Delete multiple packet generators in a best-effort manner. Generators

can only be deleted when inactive. Active or Non-existant generator ids do not cause errors. Idempotent.

func (*Client) BulkStartPacketGenerators 

func (a *Client) BulkStartPacketGenerators(params *BulkStartPacketGeneratorsParams, opts ...ClientOption) (*BulkStartPacketGeneratorsOK, error)

BulkStartPacketGenerators bulks start packet generators

Start multiple packet generators simultaneously

func (*Client) BulkStopPacketGenerators 

func (a *Client) BulkStopPacketGenerators(params *BulkStopPacketGeneratorsParams, opts ...ClientOption) (*BulkStopPacketGeneratorsNoContent, error)

BulkStopPacketGenerators bulks stop packet generators

Stop multiple packet generators simultaneously

func (*Client) CreatePacketGenerator 

func (a *Client) CreatePacketGenerator(params *CreatePacketGeneratorParams, opts ...ClientOption) (*CreatePacketGeneratorCreated, error)

CreatePacketGenerator creates a new packet generator

func (*Client) DeletePacketGenerator 

func (a *Client) DeletePacketGenerator(params *DeletePacketGeneratorParams, opts ...ClientOption) (*DeletePacketGeneratorNoContent, error)
DeletePacketGenerator deletes a packet generator

Delete a stopped packet generator by id. Also delete all results

created by this generator. Idempotent.

func (*Client) DeletePacketGeneratorResult 

func (a *Client) DeletePacketGeneratorResult(params *DeletePacketGeneratorResultParams, opts ...ClientOption) (*DeletePacketGeneratorResultNoContent, error)
DeletePacketGeneratorResult deletes a packet generator result

Delete an inactive packet generator result. Also deletes all child

tx-flow objects. Idempotent.

func (*Client) DeletePacketGeneratorResults 

func (a *Client) DeletePacketGeneratorResults(params *DeletePacketGeneratorResultsParams, opts ...ClientOption) (*DeletePacketGeneratorResultsNoContent, error)

DeletePacketGeneratorResults deletes all generator results

Delete all inactive generator results

func (*Client) DeletePacketGenerators 

func (a *Client) DeletePacketGenerators(params *DeletePacketGeneratorsParams, opts ...ClientOption) (*DeletePacketGeneratorsNoContent, error)

DeletePacketGenerators deletes all packet generators

Delete all inactive packet generators and their results. Idempotent.

func (*Client) GetPacketGenerator 

func (a *Client) GetPacketGenerator(params *GetPacketGeneratorParams, opts ...ClientOption) (*GetPacketGeneratorOK, error)

GetPacketGenerator gets a packet generator

Return a packet generator, by id.

func (*Client) GetPacketGeneratorResult 

func (a *Client) GetPacketGeneratorResult(params *GetPacketGeneratorResultParams, opts ...ClientOption) (*GetPacketGeneratorResultOK, error)

GetPacketGeneratorResult gets a packet generator result

Returns results from a packet generator by result id.

func (*Client) GetTxFlow 

func (a *Client) GetTxFlow(params *GetTxFlowParams, opts ...ClientOption) (*GetTxFlowOK, error)

GetTxFlow gets a transmit packet flow

Returns a transmit packet flow by id.

func (*Client) ListPacketGeneratorResults 

func (a *Client) ListPacketGeneratorResults(params *ListPacketGeneratorResultsParams, opts ...ClientOption) (*ListPacketGeneratorResultsOK, error)
ListPacketGeneratorResults lists generator results

The `generator-results` endpoint returns all generator results created

by generator instances.

func (*Client) ListPacketGenerators 

func (a *Client) ListPacketGenerators(params *ListPacketGeneratorsParams, opts ...ClientOption) (*ListPacketGeneratorsOK, error)
ListPacketGenerators lists packet generators

The `generators` endpoint returns all packet generators that are

configured to transmit test traffic.

func (*Client) ListTxFlows 

func (a *Client) ListTxFlows(params *ListTxFlowsParams, opts ...ClientOption) (*ListTxFlowsOK, error)
ListTxFlows lists packet generator transmit flows

The `tx-flows` endpoint returns all packet flows that are generated

by packet generators.

func (*Client) SetTransport 

func (a *Client) SetTransport(transport runtime.ClientTransport)

SetTransport changes the transport on the client

func (*Client) StartPacketGenerator 

func (a *Client) StartPacketGenerator(params *StartPacketGeneratorParams, opts ...ClientOption) (*StartPacketGeneratorCreated, error)
StartPacketGenerator starts generating packets

Used to start a non-running generator. Creates a new generator result

upon success. Sequence numbers for signature traffic start at 0.

func (*Client) StopPacketGenerator 

func (a *Client) StopPacketGenerator(params *StopPacketGeneratorParams, opts ...ClientOption) (*StopPacketGeneratorNoContent, error)

StopPacketGenerator stops generating packets

Use to halt a running generator. Idempotent.

func (*Client) TogglePacketGenerators 

func (a *Client) TogglePacketGenerators(params *TogglePacketGeneratorsParams, opts ...ClientOption) (*TogglePacketGeneratorsCreated, error)
TogglePacketGenerators replaces a running generator with a stopped generator

Atomically swap a running generator with an idle

generator. Additionally, any sequence numbers for matching signature traffic will be copied from the running generator to the idle one. Upon success, the idle generator will be in the run state, all matching signature traffic sequence numbers will continue uninterrupted, and the previously running generator will be stopped.

type ClientOption 

type ClientOption func(*runtime.ClientOperation)

ClientOption is the option for Client methods

type ClientService 

type ClientService interface {
	BulkCreatePacketGenerators(params *BulkCreatePacketGeneratorsParams, opts ...ClientOption) (*BulkCreatePacketGeneratorsOK, error)

	BulkDeletePacketGenerators(params *BulkDeletePacketGeneratorsParams, opts ...ClientOption) (*BulkDeletePacketGeneratorsNoContent, error)

	BulkStartPacketGenerators(params *BulkStartPacketGeneratorsParams, opts ...ClientOption) (*BulkStartPacketGeneratorsOK, error)

	BulkStopPacketGenerators(params *BulkStopPacketGeneratorsParams, opts ...ClientOption) (*BulkStopPacketGeneratorsNoContent, error)

	CreatePacketGenerator(params *CreatePacketGeneratorParams, opts ...ClientOption) (*CreatePacketGeneratorCreated, error)

	DeletePacketGenerator(params *DeletePacketGeneratorParams, opts ...ClientOption) (*DeletePacketGeneratorNoContent, error)

	DeletePacketGeneratorResult(params *DeletePacketGeneratorResultParams, opts ...ClientOption) (*DeletePacketGeneratorResultNoContent, error)

	DeletePacketGeneratorResults(params *DeletePacketGeneratorResultsParams, opts ...ClientOption) (*DeletePacketGeneratorResultsNoContent, error)

	DeletePacketGenerators(params *DeletePacketGeneratorsParams, opts ...ClientOption) (*DeletePacketGeneratorsNoContent, error)

	GetPacketGenerator(params *GetPacketGeneratorParams, opts ...ClientOption) (*GetPacketGeneratorOK, error)

	GetPacketGeneratorResult(params *GetPacketGeneratorResultParams, opts ...ClientOption) (*GetPacketGeneratorResultOK, error)

	GetTxFlow(params *GetTxFlowParams, opts ...ClientOption) (*GetTxFlowOK, error)

	ListPacketGeneratorResults(params *ListPacketGeneratorResultsParams, opts ...ClientOption) (*ListPacketGeneratorResultsOK, error)

	ListPacketGenerators(params *ListPacketGeneratorsParams, opts ...ClientOption) (*ListPacketGeneratorsOK, error)

	ListTxFlows(params *ListTxFlowsParams, opts ...ClientOption) (*ListTxFlowsOK, error)

	StartPacketGenerator(params *StartPacketGeneratorParams, opts ...ClientOption) (*StartPacketGeneratorCreated, error)

	StopPacketGenerator(params *StopPacketGeneratorParams, opts ...ClientOption) (*StopPacketGeneratorNoContent, error)

	TogglePacketGenerators(params *TogglePacketGeneratorsParams, opts ...ClientOption) (*TogglePacketGeneratorsCreated, error)

	SetTransport(transport runtime.ClientTransport)
}

ClientService is the interface for Client methods

func New 

func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService

New creates a new packet generators API client.

type CreatePacketGeneratorCreated 

type CreatePacketGeneratorCreated struct {

	/* URI of created generator
	 */
	Location string

	Payload *models.PacketGenerator
}
CreatePacketGeneratorCreated describes a response with status code 201, with default header values.

Created

func NewCreatePacketGeneratorCreated 

func NewCreatePacketGeneratorCreated() *CreatePacketGeneratorCreated

NewCreatePacketGeneratorCreated creates a CreatePacketGeneratorCreated with default headers values

func (*CreatePacketGeneratorCreated) Error 

func (o *CreatePacketGeneratorCreated) Error() string

func (*CreatePacketGeneratorCreated) GetPayload 

func (o *CreatePacketGeneratorCreated) GetPayload() *models.PacketGenerator

type CreatePacketGeneratorParams 

type CreatePacketGeneratorParams struct {

	/* Generator.

	   New packet generator
	*/
	Generator *models.PacketGenerator

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

CreatePacketGeneratorParams contains all the parameters to send to the API endpoint 

for the create packet generator operation.

Typically these are written to a http.Request.

func NewCreatePacketGeneratorParams 

func NewCreatePacketGeneratorParams() *CreatePacketGeneratorParams

NewCreatePacketGeneratorParams creates a new CreatePacketGeneratorParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewCreatePacketGeneratorParamsWithContext 

func NewCreatePacketGeneratorParamsWithContext(ctx context.Context) *CreatePacketGeneratorParams

NewCreatePacketGeneratorParamsWithContext creates a new CreatePacketGeneratorParams object with the ability to set a context for a request.

func NewCreatePacketGeneratorParamsWithHTTPClient 

func NewCreatePacketGeneratorParamsWithHTTPClient(client *http.Client) *CreatePacketGeneratorParams

NewCreatePacketGeneratorParamsWithHTTPClient creates a new CreatePacketGeneratorParams object with the ability to set a custom HTTPClient for a request.

func NewCreatePacketGeneratorParamsWithTimeout 

func NewCreatePacketGeneratorParamsWithTimeout(timeout time.Duration) *CreatePacketGeneratorParams

NewCreatePacketGeneratorParamsWithTimeout creates a new CreatePacketGeneratorParams object with the ability to set a timeout on a request.

func (*CreatePacketGeneratorParams) SetContext 

func (o *CreatePacketGeneratorParams) SetContext(ctx context.Context)

SetContext adds the context to the create packet generator params

func (*CreatePacketGeneratorParams) SetDefaults 

func (o *CreatePacketGeneratorParams) SetDefaults()

SetDefaults hydrates default values in the create packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*CreatePacketGeneratorParams) SetGenerator 

func (o *CreatePacketGeneratorParams) SetGenerator(generator *models.PacketGenerator)

SetGenerator adds the generator to the create packet generator params

func (*CreatePacketGeneratorParams) SetHTTPClient 

func (o *CreatePacketGeneratorParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the create packet generator params

func (*CreatePacketGeneratorParams) SetTimeout 

func (o *CreatePacketGeneratorParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the create packet generator params

func (*CreatePacketGeneratorParams) WithContext 

func (o *CreatePacketGeneratorParams) WithContext(ctx context.Context) *CreatePacketGeneratorParams

WithContext adds the context to the create packet generator params

func (*CreatePacketGeneratorParams) WithDefaults 

func (o *CreatePacketGeneratorParams) WithDefaults() *CreatePacketGeneratorParams

WithDefaults hydrates default values in the create packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*CreatePacketGeneratorParams) WithGenerator 

func (o *CreatePacketGeneratorParams) WithGenerator(generator *models.PacketGenerator) *CreatePacketGeneratorParams

WithGenerator adds the generator to the create packet generator params

func (*CreatePacketGeneratorParams) WithHTTPClient 

func (o *CreatePacketGeneratorParams) WithHTTPClient(client *http.Client) *CreatePacketGeneratorParams

WithHTTPClient adds the HTTPClient to the create packet generator params

func (*CreatePacketGeneratorParams) WithTimeout 

func (o *CreatePacketGeneratorParams) WithTimeout(timeout time.Duration) *CreatePacketGeneratorParams

WithTimeout adds the timeout to the create packet generator params

func (*CreatePacketGeneratorParams) WriteToRequest 

func (o *CreatePacketGeneratorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type CreatePacketGeneratorReader 

type CreatePacketGeneratorReader struct {
	// contains filtered or unexported fields
}

CreatePacketGeneratorReader is a Reader for the CreatePacketGenerator structure.

func (*CreatePacketGeneratorReader) ReadResponse 

func (o *CreatePacketGeneratorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type DeletePacketGeneratorNoContent 

type DeletePacketGeneratorNoContent struct {
}
DeletePacketGeneratorNoContent describes a response with status code 204, with default header values.

No Content

func NewDeletePacketGeneratorNoContent 

func NewDeletePacketGeneratorNoContent() *DeletePacketGeneratorNoContent

NewDeletePacketGeneratorNoContent creates a DeletePacketGeneratorNoContent with default headers values

func (*DeletePacketGeneratorNoContent) Error 

func (o *DeletePacketGeneratorNoContent) Error() string

type DeletePacketGeneratorParams 

type DeletePacketGeneratorParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DeletePacketGeneratorParams contains all the parameters to send to the API endpoint 

for the delete packet generator operation.

Typically these are written to a http.Request.

func NewDeletePacketGeneratorParams 

func NewDeletePacketGeneratorParams() *DeletePacketGeneratorParams

NewDeletePacketGeneratorParams creates a new DeletePacketGeneratorParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewDeletePacketGeneratorParamsWithContext 

func NewDeletePacketGeneratorParamsWithContext(ctx context.Context) *DeletePacketGeneratorParams

NewDeletePacketGeneratorParamsWithContext creates a new DeletePacketGeneratorParams object with the ability to set a context for a request.

func NewDeletePacketGeneratorParamsWithHTTPClient 

func NewDeletePacketGeneratorParamsWithHTTPClient(client *http.Client) *DeletePacketGeneratorParams

NewDeletePacketGeneratorParamsWithHTTPClient creates a new DeletePacketGeneratorParams object with the ability to set a custom HTTPClient for a request.

func NewDeletePacketGeneratorParamsWithTimeout 

func NewDeletePacketGeneratorParamsWithTimeout(timeout time.Duration) *DeletePacketGeneratorParams

NewDeletePacketGeneratorParamsWithTimeout creates a new DeletePacketGeneratorParams object with the ability to set a timeout on a request.

func (*DeletePacketGeneratorParams) SetContext 

func (o *DeletePacketGeneratorParams) SetContext(ctx context.Context)

SetContext adds the context to the delete packet generator params

func (*DeletePacketGeneratorParams) SetDefaults 

func (o *DeletePacketGeneratorParams) SetDefaults()

SetDefaults hydrates default values in the delete packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorParams) SetHTTPClient 

func (o *DeletePacketGeneratorParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the delete packet generator params

func (*DeletePacketGeneratorParams) SetID 

func (o *DeletePacketGeneratorParams) SetID(id string)

SetID adds the id to the delete packet generator params

func (*DeletePacketGeneratorParams) SetTimeout 

func (o *DeletePacketGeneratorParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the delete packet generator params

func (*DeletePacketGeneratorParams) WithContext 

func (o *DeletePacketGeneratorParams) WithContext(ctx context.Context) *DeletePacketGeneratorParams

WithContext adds the context to the delete packet generator params

func (*DeletePacketGeneratorParams) WithDefaults 

func (o *DeletePacketGeneratorParams) WithDefaults() *DeletePacketGeneratorParams

WithDefaults hydrates default values in the delete packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorParams) WithHTTPClient 

func (o *DeletePacketGeneratorParams) WithHTTPClient(client *http.Client) *DeletePacketGeneratorParams

WithHTTPClient adds the HTTPClient to the delete packet generator params

func (*DeletePacketGeneratorParams) WithID 

func (o *DeletePacketGeneratorParams) WithID(id string) *DeletePacketGeneratorParams

WithID adds the id to the delete packet generator params

func (*DeletePacketGeneratorParams) WithTimeout 

func (o *DeletePacketGeneratorParams) WithTimeout(timeout time.Duration) *DeletePacketGeneratorParams

WithTimeout adds the timeout to the delete packet generator params

func (*DeletePacketGeneratorParams) WriteToRequest 

func (o *DeletePacketGeneratorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type DeletePacketGeneratorReader 

type DeletePacketGeneratorReader struct {
	// contains filtered or unexported fields
}

DeletePacketGeneratorReader is a Reader for the DeletePacketGenerator structure.

func (*DeletePacketGeneratorReader) ReadResponse 

func (o *DeletePacketGeneratorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type DeletePacketGeneratorResultNoContent 

type DeletePacketGeneratorResultNoContent struct {
}
DeletePacketGeneratorResultNoContent describes a response with status code 204, with default header values.

No Content

func NewDeletePacketGeneratorResultNoContent 

func NewDeletePacketGeneratorResultNoContent() *DeletePacketGeneratorResultNoContent

NewDeletePacketGeneratorResultNoContent creates a DeletePacketGeneratorResultNoContent with default headers values

func (*DeletePacketGeneratorResultNoContent) Error 

func (o *DeletePacketGeneratorResultNoContent) Error() string

type DeletePacketGeneratorResultParams 

type DeletePacketGeneratorResultParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DeletePacketGeneratorResultParams contains all the parameters to send to the API endpoint 

for the delete packet generator result operation.

Typically these are written to a http.Request.

func NewDeletePacketGeneratorResultParams 

func NewDeletePacketGeneratorResultParams() *DeletePacketGeneratorResultParams

NewDeletePacketGeneratorResultParams creates a new DeletePacketGeneratorResultParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewDeletePacketGeneratorResultParamsWithContext 

func NewDeletePacketGeneratorResultParamsWithContext(ctx context.Context) *DeletePacketGeneratorResultParams

NewDeletePacketGeneratorResultParamsWithContext creates a new DeletePacketGeneratorResultParams object with the ability to set a context for a request.

func NewDeletePacketGeneratorResultParamsWithHTTPClient 

func NewDeletePacketGeneratorResultParamsWithHTTPClient(client *http.Client) *DeletePacketGeneratorResultParams

NewDeletePacketGeneratorResultParamsWithHTTPClient creates a new DeletePacketGeneratorResultParams object with the ability to set a custom HTTPClient for a request.

func NewDeletePacketGeneratorResultParamsWithTimeout 

func NewDeletePacketGeneratorResultParamsWithTimeout(timeout time.Duration) *DeletePacketGeneratorResultParams

NewDeletePacketGeneratorResultParamsWithTimeout creates a new DeletePacketGeneratorResultParams object with the ability to set a timeout on a request.

func (*DeletePacketGeneratorResultParams) SetContext 

func (o *DeletePacketGeneratorResultParams) SetContext(ctx context.Context)

SetContext adds the context to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) SetDefaults 

func (o *DeletePacketGeneratorResultParams) SetDefaults()

SetDefaults hydrates default values in the delete packet generator result params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorResultParams) SetHTTPClient 

func (o *DeletePacketGeneratorResultParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) SetID 

func (o *DeletePacketGeneratorResultParams) SetID(id string)

SetID adds the id to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) SetTimeout 

func (o *DeletePacketGeneratorResultParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) WithContext 

func (o *DeletePacketGeneratorResultParams) WithContext(ctx context.Context) *DeletePacketGeneratorResultParams

WithContext adds the context to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) WithDefaults 

func (o *DeletePacketGeneratorResultParams) WithDefaults() *DeletePacketGeneratorResultParams

WithDefaults hydrates default values in the delete packet generator result params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorResultParams) WithHTTPClient 

func (o *DeletePacketGeneratorResultParams) WithHTTPClient(client *http.Client) *DeletePacketGeneratorResultParams

WithHTTPClient adds the HTTPClient to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) WithID 

func (o *DeletePacketGeneratorResultParams) WithID(id string) *DeletePacketGeneratorResultParams

WithID adds the id to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) WithTimeout 

func (o *DeletePacketGeneratorResultParams) WithTimeout(timeout time.Duration) *DeletePacketGeneratorResultParams

WithTimeout adds the timeout to the delete packet generator result params

func (*DeletePacketGeneratorResultParams) WriteToRequest 

func (o *DeletePacketGeneratorResultParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type DeletePacketGeneratorResultReader 

type DeletePacketGeneratorResultReader struct {
	// contains filtered or unexported fields
}

DeletePacketGeneratorResultReader is a Reader for the DeletePacketGeneratorResult structure.

func (*DeletePacketGeneratorResultReader) ReadResponse 

func (o *DeletePacketGeneratorResultReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type DeletePacketGeneratorResultsNoContent 

type DeletePacketGeneratorResultsNoContent struct {
}
DeletePacketGeneratorResultsNoContent describes a response with status code 204, with default header values.

No Content

func NewDeletePacketGeneratorResultsNoContent 

func NewDeletePacketGeneratorResultsNoContent() *DeletePacketGeneratorResultsNoContent

NewDeletePacketGeneratorResultsNoContent creates a DeletePacketGeneratorResultsNoContent with default headers values

func (*DeletePacketGeneratorResultsNoContent) Error 

func (o *DeletePacketGeneratorResultsNoContent) Error() string

type DeletePacketGeneratorResultsParams 

type DeletePacketGeneratorResultsParams struct {
	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DeletePacketGeneratorResultsParams contains all the parameters to send to the API endpoint 

for the delete packet generator results operation.

Typically these are written to a http.Request.

func NewDeletePacketGeneratorResultsParams 

func NewDeletePacketGeneratorResultsParams() *DeletePacketGeneratorResultsParams

NewDeletePacketGeneratorResultsParams creates a new DeletePacketGeneratorResultsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewDeletePacketGeneratorResultsParamsWithContext 

func NewDeletePacketGeneratorResultsParamsWithContext(ctx context.Context) *DeletePacketGeneratorResultsParams

NewDeletePacketGeneratorResultsParamsWithContext creates a new DeletePacketGeneratorResultsParams object with the ability to set a context for a request.

func NewDeletePacketGeneratorResultsParamsWithHTTPClient 

func NewDeletePacketGeneratorResultsParamsWithHTTPClient(client *http.Client) *DeletePacketGeneratorResultsParams

NewDeletePacketGeneratorResultsParamsWithHTTPClient creates a new DeletePacketGeneratorResultsParams object with the ability to set a custom HTTPClient for a request.

func NewDeletePacketGeneratorResultsParamsWithTimeout 

func NewDeletePacketGeneratorResultsParamsWithTimeout(timeout time.Duration) *DeletePacketGeneratorResultsParams

NewDeletePacketGeneratorResultsParamsWithTimeout creates a new DeletePacketGeneratorResultsParams object with the ability to set a timeout on a request.

func (*DeletePacketGeneratorResultsParams) SetContext 

func (o *DeletePacketGeneratorResultsParams) SetContext(ctx context.Context)

SetContext adds the context to the delete packet generator results params

func (*DeletePacketGeneratorResultsParams) SetDefaults 

func (o *DeletePacketGeneratorResultsParams) SetDefaults()

SetDefaults hydrates default values in the delete packet generator results params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorResultsParams) SetHTTPClient 

func (o *DeletePacketGeneratorResultsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the delete packet generator results params

func (*DeletePacketGeneratorResultsParams) SetTimeout 

func (o *DeletePacketGeneratorResultsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the delete packet generator results params

func (*DeletePacketGeneratorResultsParams) WithContext 

func (o *DeletePacketGeneratorResultsParams) WithContext(ctx context.Context) *DeletePacketGeneratorResultsParams

WithContext adds the context to the delete packet generator results params

func (*DeletePacketGeneratorResultsParams) WithDefaults 

func (o *DeletePacketGeneratorResultsParams) WithDefaults() *DeletePacketGeneratorResultsParams

WithDefaults hydrates default values in the delete packet generator results params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorResultsParams) WithHTTPClient 

func (o *DeletePacketGeneratorResultsParams) WithHTTPClient(client *http.Client) *DeletePacketGeneratorResultsParams

WithHTTPClient adds the HTTPClient to the delete packet generator results params

func (*DeletePacketGeneratorResultsParams) WithTimeout 

func (o *DeletePacketGeneratorResultsParams) WithTimeout(timeout time.Duration) *DeletePacketGeneratorResultsParams

WithTimeout adds the timeout to the delete packet generator results params

func (*DeletePacketGeneratorResultsParams) WriteToRequest 

func (o *DeletePacketGeneratorResultsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type DeletePacketGeneratorResultsReader 

type DeletePacketGeneratorResultsReader struct {
	// contains filtered or unexported fields
}

DeletePacketGeneratorResultsReader is a Reader for the DeletePacketGeneratorResults structure.

func (*DeletePacketGeneratorResultsReader) ReadResponse 

func (o *DeletePacketGeneratorResultsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type DeletePacketGeneratorsNoContent 

type DeletePacketGeneratorsNoContent struct {
}
DeletePacketGeneratorsNoContent describes a response with status code 204, with default header values.

No Content

func NewDeletePacketGeneratorsNoContent 

func NewDeletePacketGeneratorsNoContent() *DeletePacketGeneratorsNoContent

NewDeletePacketGeneratorsNoContent creates a DeletePacketGeneratorsNoContent with default headers values

func (*DeletePacketGeneratorsNoContent) Error 

func (o *DeletePacketGeneratorsNoContent) Error() string

type DeletePacketGeneratorsParams 

type DeletePacketGeneratorsParams struct {
	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DeletePacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the delete packet generators operation.

Typically these are written to a http.Request.

func NewDeletePacketGeneratorsParams 

func NewDeletePacketGeneratorsParams() *DeletePacketGeneratorsParams

NewDeletePacketGeneratorsParams creates a new DeletePacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewDeletePacketGeneratorsParamsWithContext 

func NewDeletePacketGeneratorsParamsWithContext(ctx context.Context) *DeletePacketGeneratorsParams

NewDeletePacketGeneratorsParamsWithContext creates a new DeletePacketGeneratorsParams object with the ability to set a context for a request.

func NewDeletePacketGeneratorsParamsWithHTTPClient 

func NewDeletePacketGeneratorsParamsWithHTTPClient(client *http.Client) *DeletePacketGeneratorsParams

NewDeletePacketGeneratorsParamsWithHTTPClient creates a new DeletePacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewDeletePacketGeneratorsParamsWithTimeout 

func NewDeletePacketGeneratorsParamsWithTimeout(timeout time.Duration) *DeletePacketGeneratorsParams

NewDeletePacketGeneratorsParamsWithTimeout creates a new DeletePacketGeneratorsParams object with the ability to set a timeout on a request.

func (*DeletePacketGeneratorsParams) SetContext 

func (o *DeletePacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the delete packet generators params

func (*DeletePacketGeneratorsParams) SetDefaults 

func (o *DeletePacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the delete packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorsParams) SetHTTPClient 

func (o *DeletePacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the delete packet generators params

func (*DeletePacketGeneratorsParams) SetTimeout 

func (o *DeletePacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the delete packet generators params

func (*DeletePacketGeneratorsParams) WithContext 

func (o *DeletePacketGeneratorsParams) WithContext(ctx context.Context) *DeletePacketGeneratorsParams

WithContext adds the context to the delete packet generators params

func (*DeletePacketGeneratorsParams) WithDefaults 

func (o *DeletePacketGeneratorsParams) WithDefaults() *DeletePacketGeneratorsParams

WithDefaults hydrates default values in the delete packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*DeletePacketGeneratorsParams) WithHTTPClient 

func (o *DeletePacketGeneratorsParams) WithHTTPClient(client *http.Client) *DeletePacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the delete packet generators params

func (*DeletePacketGeneratorsParams) WithTimeout 

func (o *DeletePacketGeneratorsParams) WithTimeout(timeout time.Duration) *DeletePacketGeneratorsParams

WithTimeout adds the timeout to the delete packet generators params

func (*DeletePacketGeneratorsParams) WriteToRequest 

func (o *DeletePacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type DeletePacketGeneratorsReader 

type DeletePacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

DeletePacketGeneratorsReader is a Reader for the DeletePacketGenerators structure.

func (*DeletePacketGeneratorsReader) ReadResponse 

func (o *DeletePacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type GetPacketGeneratorOK 

type GetPacketGeneratorOK struct {
	Payload *models.PacketGenerator
}
GetPacketGeneratorOK describes a response with status code 200, with default header values.

Success

func NewGetPacketGeneratorOK 

func NewGetPacketGeneratorOK() *GetPacketGeneratorOK

NewGetPacketGeneratorOK creates a GetPacketGeneratorOK with default headers values

func (*GetPacketGeneratorOK) Error 

func (o *GetPacketGeneratorOK) Error() string

func (*GetPacketGeneratorOK) GetPayload 

func (o *GetPacketGeneratorOK) GetPayload() *models.PacketGenerator

type GetPacketGeneratorParams 

type GetPacketGeneratorParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetPacketGeneratorParams contains all the parameters to send to the API endpoint 

for the get packet generator operation.

Typically these are written to a http.Request.

func NewGetPacketGeneratorParams 

func NewGetPacketGeneratorParams() *GetPacketGeneratorParams

NewGetPacketGeneratorParams creates a new GetPacketGeneratorParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewGetPacketGeneratorParamsWithContext 

func NewGetPacketGeneratorParamsWithContext(ctx context.Context) *GetPacketGeneratorParams

NewGetPacketGeneratorParamsWithContext creates a new GetPacketGeneratorParams object with the ability to set a context for a request.

func NewGetPacketGeneratorParamsWithHTTPClient 

func NewGetPacketGeneratorParamsWithHTTPClient(client *http.Client) *GetPacketGeneratorParams

NewGetPacketGeneratorParamsWithHTTPClient creates a new GetPacketGeneratorParams object with the ability to set a custom HTTPClient for a request.

func NewGetPacketGeneratorParamsWithTimeout 

func NewGetPacketGeneratorParamsWithTimeout(timeout time.Duration) *GetPacketGeneratorParams

NewGetPacketGeneratorParamsWithTimeout creates a new GetPacketGeneratorParams object with the ability to set a timeout on a request.

func (*GetPacketGeneratorParams) SetContext 

func (o *GetPacketGeneratorParams) SetContext(ctx context.Context)

SetContext adds the context to the get packet generator params

func (*GetPacketGeneratorParams) SetDefaults 

func (o *GetPacketGeneratorParams) SetDefaults()

SetDefaults hydrates default values in the get packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*GetPacketGeneratorParams) SetHTTPClient 

func (o *GetPacketGeneratorParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get packet generator params

func (*GetPacketGeneratorParams) SetID 

func (o *GetPacketGeneratorParams) SetID(id string)

SetID adds the id to the get packet generator params

func (*GetPacketGeneratorParams) SetTimeout 

func (o *GetPacketGeneratorParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get packet generator params

func (*GetPacketGeneratorParams) WithContext 

func (o *GetPacketGeneratorParams) WithContext(ctx context.Context) *GetPacketGeneratorParams

WithContext adds the context to the get packet generator params

func (*GetPacketGeneratorParams) WithDefaults 

func (o *GetPacketGeneratorParams) WithDefaults() *GetPacketGeneratorParams

WithDefaults hydrates default values in the get packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*GetPacketGeneratorParams) WithHTTPClient 

func (o *GetPacketGeneratorParams) WithHTTPClient(client *http.Client) *GetPacketGeneratorParams

WithHTTPClient adds the HTTPClient to the get packet generator params

func (*GetPacketGeneratorParams) WithID 

func (o *GetPacketGeneratorParams) WithID(id string) *GetPacketGeneratorParams

WithID adds the id to the get packet generator params

func (*GetPacketGeneratorParams) WithTimeout 

func (o *GetPacketGeneratorParams) WithTimeout(timeout time.Duration) *GetPacketGeneratorParams

WithTimeout adds the timeout to the get packet generator params

func (*GetPacketGeneratorParams) WriteToRequest 

func (o *GetPacketGeneratorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type GetPacketGeneratorReader 

type GetPacketGeneratorReader struct {
	// contains filtered or unexported fields
}

GetPacketGeneratorReader is a Reader for the GetPacketGenerator structure.

func (*GetPacketGeneratorReader) ReadResponse 

func (o *GetPacketGeneratorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type GetPacketGeneratorResultOK 

type GetPacketGeneratorResultOK struct {
	Payload *models.PacketGeneratorResult
}
GetPacketGeneratorResultOK describes a response with status code 200, with default header values.

Success

func NewGetPacketGeneratorResultOK 

func NewGetPacketGeneratorResultOK() *GetPacketGeneratorResultOK

NewGetPacketGeneratorResultOK creates a GetPacketGeneratorResultOK with default headers values

func (*GetPacketGeneratorResultOK) Error 

func (o *GetPacketGeneratorResultOK) Error() string

func (*GetPacketGeneratorResultOK) GetPayload 

func (o *GetPacketGeneratorResultOK) GetPayload() *models.PacketGeneratorResult

type GetPacketGeneratorResultParams 

type GetPacketGeneratorResultParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetPacketGeneratorResultParams contains all the parameters to send to the API endpoint 

for the get packet generator result operation.

Typically these are written to a http.Request.

func NewGetPacketGeneratorResultParams 

func NewGetPacketGeneratorResultParams() *GetPacketGeneratorResultParams

NewGetPacketGeneratorResultParams creates a new GetPacketGeneratorResultParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewGetPacketGeneratorResultParamsWithContext 

func NewGetPacketGeneratorResultParamsWithContext(ctx context.Context) *GetPacketGeneratorResultParams

NewGetPacketGeneratorResultParamsWithContext creates a new GetPacketGeneratorResultParams object with the ability to set a context for a request.

func NewGetPacketGeneratorResultParamsWithHTTPClient 

func NewGetPacketGeneratorResultParamsWithHTTPClient(client *http.Client) *GetPacketGeneratorResultParams

NewGetPacketGeneratorResultParamsWithHTTPClient creates a new GetPacketGeneratorResultParams object with the ability to set a custom HTTPClient for a request.

func NewGetPacketGeneratorResultParamsWithTimeout 

func NewGetPacketGeneratorResultParamsWithTimeout(timeout time.Duration) *GetPacketGeneratorResultParams

NewGetPacketGeneratorResultParamsWithTimeout creates a new GetPacketGeneratorResultParams object with the ability to set a timeout on a request.

func (*GetPacketGeneratorResultParams) SetContext 

func (o *GetPacketGeneratorResultParams) SetContext(ctx context.Context)

SetContext adds the context to the get packet generator result params

func (*GetPacketGeneratorResultParams) SetDefaults 

func (o *GetPacketGeneratorResultParams) SetDefaults()

SetDefaults hydrates default values in the get packet generator result params (not the query body).

All values with no default are reset to their zero value.

func (*GetPacketGeneratorResultParams) SetHTTPClient 

func (o *GetPacketGeneratorResultParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get packet generator result params

func (*GetPacketGeneratorResultParams) SetID 

func (o *GetPacketGeneratorResultParams) SetID(id string)

SetID adds the id to the get packet generator result params

func (*GetPacketGeneratorResultParams) SetTimeout 

func (o *GetPacketGeneratorResultParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get packet generator result params

func (*GetPacketGeneratorResultParams) WithContext 

func (o *GetPacketGeneratorResultParams) WithContext(ctx context.Context) *GetPacketGeneratorResultParams

WithContext adds the context to the get packet generator result params

func (*GetPacketGeneratorResultParams) WithDefaults 

func (o *GetPacketGeneratorResultParams) WithDefaults() *GetPacketGeneratorResultParams

WithDefaults hydrates default values in the get packet generator result params (not the query body).

All values with no default are reset to their zero value.

func (*GetPacketGeneratorResultParams) WithHTTPClient 

func (o *GetPacketGeneratorResultParams) WithHTTPClient(client *http.Client) *GetPacketGeneratorResultParams

WithHTTPClient adds the HTTPClient to the get packet generator result params

func (*GetPacketGeneratorResultParams) WithID 

func (o *GetPacketGeneratorResultParams) WithID(id string) *GetPacketGeneratorResultParams

WithID adds the id to the get packet generator result params

func (*GetPacketGeneratorResultParams) WithTimeout 

func (o *GetPacketGeneratorResultParams) WithTimeout(timeout time.Duration) *GetPacketGeneratorResultParams

WithTimeout adds the timeout to the get packet generator result params

func (*GetPacketGeneratorResultParams) WriteToRequest 

func (o *GetPacketGeneratorResultParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type GetPacketGeneratorResultReader 

type GetPacketGeneratorResultReader struct {
	// contains filtered or unexported fields
}

GetPacketGeneratorResultReader is a Reader for the GetPacketGeneratorResult structure.

func (*GetPacketGeneratorResultReader) ReadResponse 

func (o *GetPacketGeneratorResultReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type GetTxFlowOK 

type GetTxFlowOK struct {
	Payload *models.TxFlow
}
GetTxFlowOK describes a response with status code 200, with default header values.

Success

func NewGetTxFlowOK 

func NewGetTxFlowOK() *GetTxFlowOK

NewGetTxFlowOK creates a GetTxFlowOK with default headers values

func (*GetTxFlowOK) Error 

func (o *GetTxFlowOK) Error() string

func (*GetTxFlowOK) GetPayload 

func (o *GetTxFlowOK) GetPayload() *models.TxFlow

type GetTxFlowParams 

type GetTxFlowParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetTxFlowParams contains all the parameters to send to the API endpoint 

for the get tx flow operation.

Typically these are written to a http.Request.

func NewGetTxFlowParams 

func NewGetTxFlowParams() *GetTxFlowParams

NewGetTxFlowParams creates a new GetTxFlowParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewGetTxFlowParamsWithContext 

func NewGetTxFlowParamsWithContext(ctx context.Context) *GetTxFlowParams

NewGetTxFlowParamsWithContext creates a new GetTxFlowParams object with the ability to set a context for a request.

func NewGetTxFlowParamsWithHTTPClient 

func NewGetTxFlowParamsWithHTTPClient(client *http.Client) *GetTxFlowParams

NewGetTxFlowParamsWithHTTPClient creates a new GetTxFlowParams object with the ability to set a custom HTTPClient for a request.

func NewGetTxFlowParamsWithTimeout 

func NewGetTxFlowParamsWithTimeout(timeout time.Duration) *GetTxFlowParams

NewGetTxFlowParamsWithTimeout creates a new GetTxFlowParams object with the ability to set a timeout on a request.

func (*GetTxFlowParams) SetContext 

func (o *GetTxFlowParams) SetContext(ctx context.Context)

SetContext adds the context to the get tx flow params

func (*GetTxFlowParams) SetDefaults 

func (o *GetTxFlowParams) SetDefaults()

SetDefaults hydrates default values in the get tx flow params (not the query body).

All values with no default are reset to their zero value.

func (*GetTxFlowParams) SetHTTPClient 

func (o *GetTxFlowParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get tx flow params

func (*GetTxFlowParams) SetID 

func (o *GetTxFlowParams) SetID(id string)

SetID adds the id to the get tx flow params

func (*GetTxFlowParams) SetTimeout 

func (o *GetTxFlowParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get tx flow params

func (*GetTxFlowParams) WithContext 

func (o *GetTxFlowParams) WithContext(ctx context.Context) *GetTxFlowParams

WithContext adds the context to the get tx flow params

func (*GetTxFlowParams) WithDefaults 

func (o *GetTxFlowParams) WithDefaults() *GetTxFlowParams

WithDefaults hydrates default values in the get tx flow params (not the query body).

All values with no default are reset to their zero value.

func (*GetTxFlowParams) WithHTTPClient 

func (o *GetTxFlowParams) WithHTTPClient(client *http.Client) *GetTxFlowParams

WithHTTPClient adds the HTTPClient to the get tx flow params

func (*GetTxFlowParams) WithID 

func (o *GetTxFlowParams) WithID(id string) *GetTxFlowParams

WithID adds the id to the get tx flow params

func (*GetTxFlowParams) WithTimeout 

func (o *GetTxFlowParams) WithTimeout(timeout time.Duration) *GetTxFlowParams

WithTimeout adds the timeout to the get tx flow params

func (*GetTxFlowParams) WriteToRequest 

func (o *GetTxFlowParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type GetTxFlowReader 

type GetTxFlowReader struct {
	// contains filtered or unexported fields
}

GetTxFlowReader is a Reader for the GetTxFlow structure.

func (*GetTxFlowReader) ReadResponse 

func (o *GetTxFlowReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type ListPacketGeneratorResultsOK 

type ListPacketGeneratorResultsOK struct {
	Payload []*models.PacketGeneratorResult
}
ListPacketGeneratorResultsOK describes a response with status code 200, with default header values.

Success

func NewListPacketGeneratorResultsOK 

func NewListPacketGeneratorResultsOK() *ListPacketGeneratorResultsOK

NewListPacketGeneratorResultsOK creates a ListPacketGeneratorResultsOK with default headers values

func (*ListPacketGeneratorResultsOK) Error 

func (o *ListPacketGeneratorResultsOK) Error() string

func (*ListPacketGeneratorResultsOK) GetPayload 

func (o *ListPacketGeneratorResultsOK) GetPayload() []*models.PacketGeneratorResult

type ListPacketGeneratorResultsParams 

type ListPacketGeneratorResultsParams struct {

	/* GeneratorID.

	   Filter by generator id
	*/
	GeneratorID *string

	/* TargetID.

	   Filter by target port or interface id
	*/
	TargetID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

ListPacketGeneratorResultsParams contains all the parameters to send to the API endpoint 

for the list packet generator results operation.

Typically these are written to a http.Request.

func NewListPacketGeneratorResultsParams 

func NewListPacketGeneratorResultsParams() *ListPacketGeneratorResultsParams

NewListPacketGeneratorResultsParams creates a new ListPacketGeneratorResultsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewListPacketGeneratorResultsParamsWithContext 

func NewListPacketGeneratorResultsParamsWithContext(ctx context.Context) *ListPacketGeneratorResultsParams

NewListPacketGeneratorResultsParamsWithContext creates a new ListPacketGeneratorResultsParams object with the ability to set a context for a request.

func NewListPacketGeneratorResultsParamsWithHTTPClient 

func NewListPacketGeneratorResultsParamsWithHTTPClient(client *http.Client) *ListPacketGeneratorResultsParams

NewListPacketGeneratorResultsParamsWithHTTPClient creates a new ListPacketGeneratorResultsParams object with the ability to set a custom HTTPClient for a request.

func NewListPacketGeneratorResultsParamsWithTimeout 

func NewListPacketGeneratorResultsParamsWithTimeout(timeout time.Duration) *ListPacketGeneratorResultsParams

NewListPacketGeneratorResultsParamsWithTimeout creates a new ListPacketGeneratorResultsParams object with the ability to set a timeout on a request.

func (*ListPacketGeneratorResultsParams) SetContext 

func (o *ListPacketGeneratorResultsParams) SetContext(ctx context.Context)

SetContext adds the context to the list packet generator results params

func (*ListPacketGeneratorResultsParams) SetDefaults 

func (o *ListPacketGeneratorResultsParams) SetDefaults()

SetDefaults hydrates default values in the list packet generator results params (not the query body).

All values with no default are reset to their zero value.

func (*ListPacketGeneratorResultsParams) SetGeneratorID 

func (o *ListPacketGeneratorResultsParams) SetGeneratorID(generatorID *string)

SetGeneratorID adds the generatorId to the list packet generator results params

func (*ListPacketGeneratorResultsParams) SetHTTPClient 

func (o *ListPacketGeneratorResultsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the list packet generator results params

func (*ListPacketGeneratorResultsParams) SetTargetID 

func (o *ListPacketGeneratorResultsParams) SetTargetID(targetID *string)

SetTargetID adds the targetId to the list packet generator results params

func (*ListPacketGeneratorResultsParams) SetTimeout 

func (o *ListPacketGeneratorResultsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the list packet generator results params

func (*ListPacketGeneratorResultsParams) WithContext 

func (o *ListPacketGeneratorResultsParams) WithContext(ctx context.Context) *ListPacketGeneratorResultsParams

WithContext adds the context to the list packet generator results params

func (*ListPacketGeneratorResultsParams) WithDefaults 

func (o *ListPacketGeneratorResultsParams) WithDefaults() *ListPacketGeneratorResultsParams

WithDefaults hydrates default values in the list packet generator results params (not the query body).

All values with no default are reset to their zero value.

func (*ListPacketGeneratorResultsParams) WithGeneratorID 

func (o *ListPacketGeneratorResultsParams) WithGeneratorID(generatorID *string) *ListPacketGeneratorResultsParams

WithGeneratorID adds the generatorID to the list packet generator results params

func (*ListPacketGeneratorResultsParams) WithHTTPClient 

func (o *ListPacketGeneratorResultsParams) WithHTTPClient(client *http.Client) *ListPacketGeneratorResultsParams

WithHTTPClient adds the HTTPClient to the list packet generator results params

func (*ListPacketGeneratorResultsParams) WithTargetID 

func (o *ListPacketGeneratorResultsParams) WithTargetID(targetID *string) *ListPacketGeneratorResultsParams

WithTargetID adds the targetID to the list packet generator results params

func (*ListPacketGeneratorResultsParams) WithTimeout 

func (o *ListPacketGeneratorResultsParams) WithTimeout(timeout time.Duration) *ListPacketGeneratorResultsParams

WithTimeout adds the timeout to the list packet generator results params

func (*ListPacketGeneratorResultsParams) WriteToRequest 

func (o *ListPacketGeneratorResultsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type ListPacketGeneratorResultsReader 

type ListPacketGeneratorResultsReader struct {
	// contains filtered or unexported fields
}

ListPacketGeneratorResultsReader is a Reader for the ListPacketGeneratorResults structure.

func (*ListPacketGeneratorResultsReader) ReadResponse 

func (o *ListPacketGeneratorResultsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type ListPacketGeneratorsOK 

type ListPacketGeneratorsOK struct {
	Payload []*models.PacketGenerator
}
ListPacketGeneratorsOK describes a response with status code 200, with default header values.

Success

func NewListPacketGeneratorsOK 

func NewListPacketGeneratorsOK() *ListPacketGeneratorsOK

NewListPacketGeneratorsOK creates a ListPacketGeneratorsOK with default headers values

func (*ListPacketGeneratorsOK) Error 

func (o *ListPacketGeneratorsOK) Error() string

func (*ListPacketGeneratorsOK) GetPayload 

func (o *ListPacketGeneratorsOK) GetPayload() []*models.PacketGenerator

type ListPacketGeneratorsParams 

type ListPacketGeneratorsParams struct {

	/* TargetID.

	   Filter by target id
	*/
	TargetID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

ListPacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the list packet generators operation.

Typically these are written to a http.Request.

func NewListPacketGeneratorsParams 

func NewListPacketGeneratorsParams() *ListPacketGeneratorsParams

NewListPacketGeneratorsParams creates a new ListPacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewListPacketGeneratorsParamsWithContext 

func NewListPacketGeneratorsParamsWithContext(ctx context.Context) *ListPacketGeneratorsParams

NewListPacketGeneratorsParamsWithContext creates a new ListPacketGeneratorsParams object with the ability to set a context for a request.

func NewListPacketGeneratorsParamsWithHTTPClient 

func NewListPacketGeneratorsParamsWithHTTPClient(client *http.Client) *ListPacketGeneratorsParams

NewListPacketGeneratorsParamsWithHTTPClient creates a new ListPacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewListPacketGeneratorsParamsWithTimeout 

func NewListPacketGeneratorsParamsWithTimeout(timeout time.Duration) *ListPacketGeneratorsParams

NewListPacketGeneratorsParamsWithTimeout creates a new ListPacketGeneratorsParams object with the ability to set a timeout on a request.

func (*ListPacketGeneratorsParams) SetContext 

func (o *ListPacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the list packet generators params

func (*ListPacketGeneratorsParams) SetDefaults 

func (o *ListPacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the list packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*ListPacketGeneratorsParams) SetHTTPClient 

func (o *ListPacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the list packet generators params

func (*ListPacketGeneratorsParams) SetTargetID 

func (o *ListPacketGeneratorsParams) SetTargetID(targetID *string)

SetTargetID adds the targetId to the list packet generators params

func (*ListPacketGeneratorsParams) SetTimeout 

func (o *ListPacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the list packet generators params

func (*ListPacketGeneratorsParams) WithContext 

func (o *ListPacketGeneratorsParams) WithContext(ctx context.Context) *ListPacketGeneratorsParams

WithContext adds the context to the list packet generators params

func (*ListPacketGeneratorsParams) WithDefaults 

func (o *ListPacketGeneratorsParams) WithDefaults() *ListPacketGeneratorsParams

WithDefaults hydrates default values in the list packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*ListPacketGeneratorsParams) WithHTTPClient 

func (o *ListPacketGeneratorsParams) WithHTTPClient(client *http.Client) *ListPacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the list packet generators params

func (*ListPacketGeneratorsParams) WithTargetID 

func (o *ListPacketGeneratorsParams) WithTargetID(targetID *string) *ListPacketGeneratorsParams

WithTargetID adds the targetID to the list packet generators params

func (*ListPacketGeneratorsParams) WithTimeout 

func (o *ListPacketGeneratorsParams) WithTimeout(timeout time.Duration) *ListPacketGeneratorsParams

WithTimeout adds the timeout to the list packet generators params

func (*ListPacketGeneratorsParams) WriteToRequest 

func (o *ListPacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type ListPacketGeneratorsReader 

type ListPacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

ListPacketGeneratorsReader is a Reader for the ListPacketGenerators structure.

func (*ListPacketGeneratorsReader) ReadResponse 

func (o *ListPacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type ListTxFlowsOK 

type ListTxFlowsOK struct {
	Payload []*models.TxFlow
}
ListTxFlowsOK describes a response with status code 200, with default header values.

Success

func NewListTxFlowsOK 

func NewListTxFlowsOK() *ListTxFlowsOK

NewListTxFlowsOK creates a ListTxFlowsOK with default headers values

func (*ListTxFlowsOK) Error 

func (o *ListTxFlowsOK) Error() string

func (*ListTxFlowsOK) GetPayload 

func (o *ListTxFlowsOK) GetPayload() []*models.TxFlow

type ListTxFlowsParams 

type ListTxFlowsParams struct {

	/* GeneratorID.

	   Filter by packet generator id
	*/
	GeneratorID *string

	/* TargetID.

	   Filter by target port or interface id
	*/
	TargetID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

ListTxFlowsParams contains all the parameters to send to the API endpoint 

for the list tx flows operation.

Typically these are written to a http.Request.

func NewListTxFlowsParams 

func NewListTxFlowsParams() *ListTxFlowsParams

NewListTxFlowsParams creates a new ListTxFlowsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewListTxFlowsParamsWithContext 

func NewListTxFlowsParamsWithContext(ctx context.Context) *ListTxFlowsParams

NewListTxFlowsParamsWithContext creates a new ListTxFlowsParams object with the ability to set a context for a request.

func NewListTxFlowsParamsWithHTTPClient 

func NewListTxFlowsParamsWithHTTPClient(client *http.Client) *ListTxFlowsParams

NewListTxFlowsParamsWithHTTPClient creates a new ListTxFlowsParams object with the ability to set a custom HTTPClient for a request.

func NewListTxFlowsParamsWithTimeout 

func NewListTxFlowsParamsWithTimeout(timeout time.Duration) *ListTxFlowsParams

NewListTxFlowsParamsWithTimeout creates a new ListTxFlowsParams object with the ability to set a timeout on a request.

func (*ListTxFlowsParams) SetContext 

func (o *ListTxFlowsParams) SetContext(ctx context.Context)

SetContext adds the context to the list tx flows params

func (*ListTxFlowsParams) SetDefaults 

func (o *ListTxFlowsParams) SetDefaults()

SetDefaults hydrates default values in the list tx flows params (not the query body).

All values with no default are reset to their zero value.

func (*ListTxFlowsParams) SetGeneratorID 

func (o *ListTxFlowsParams) SetGeneratorID(generatorID *string)

SetGeneratorID adds the generatorId to the list tx flows params

func (*ListTxFlowsParams) SetHTTPClient 

func (o *ListTxFlowsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the list tx flows params

func (*ListTxFlowsParams) SetTargetID 

func (o *ListTxFlowsParams) SetTargetID(targetID *string)

SetTargetID adds the targetId to the list tx flows params

func (*ListTxFlowsParams) SetTimeout 

func (o *ListTxFlowsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the list tx flows params

func (*ListTxFlowsParams) WithContext 

func (o *ListTxFlowsParams) WithContext(ctx context.Context) *ListTxFlowsParams

WithContext adds the context to the list tx flows params

func (*ListTxFlowsParams) WithDefaults 

func (o *ListTxFlowsParams) WithDefaults() *ListTxFlowsParams

WithDefaults hydrates default values in the list tx flows params (not the query body).

All values with no default are reset to their zero value.

func (*ListTxFlowsParams) WithGeneratorID 

func (o *ListTxFlowsParams) WithGeneratorID(generatorID *string) *ListTxFlowsParams

WithGeneratorID adds the generatorID to the list tx flows params

func (*ListTxFlowsParams) WithHTTPClient 

func (o *ListTxFlowsParams) WithHTTPClient(client *http.Client) *ListTxFlowsParams

WithHTTPClient adds the HTTPClient to the list tx flows params

func (*ListTxFlowsParams) WithTargetID 

func (o *ListTxFlowsParams) WithTargetID(targetID *string) *ListTxFlowsParams

WithTargetID adds the targetID to the list tx flows params

func (*ListTxFlowsParams) WithTimeout 

func (o *ListTxFlowsParams) WithTimeout(timeout time.Duration) *ListTxFlowsParams

WithTimeout adds the timeout to the list tx flows params

func (*ListTxFlowsParams) WriteToRequest 

func (o *ListTxFlowsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type ListTxFlowsReader 

type ListTxFlowsReader struct {
	// contains filtered or unexported fields
}

ListTxFlowsReader is a Reader for the ListTxFlows structure.

func (*ListTxFlowsReader) ReadResponse 

func (o *ListTxFlowsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type StartPacketGeneratorCreated 

type StartPacketGeneratorCreated struct {

	/* URI to created generator result object
	 */
	Location string

	Payload *models.PacketGeneratorResult
}
StartPacketGeneratorCreated describes a response with status code 201, with default header values.

Created

func NewStartPacketGeneratorCreated 

func NewStartPacketGeneratorCreated() *StartPacketGeneratorCreated

NewStartPacketGeneratorCreated creates a StartPacketGeneratorCreated with default headers values

func (*StartPacketGeneratorCreated) Error 

func (o *StartPacketGeneratorCreated) Error() string

func (*StartPacketGeneratorCreated) GetPayload 

func (o *StartPacketGeneratorCreated) GetPayload() *models.PacketGeneratorResult

type StartPacketGeneratorParams 

type StartPacketGeneratorParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

StartPacketGeneratorParams contains all the parameters to send to the API endpoint 

for the start packet generator operation.

Typically these are written to a http.Request.

func NewStartPacketGeneratorParams 

func NewStartPacketGeneratorParams() *StartPacketGeneratorParams

NewStartPacketGeneratorParams creates a new StartPacketGeneratorParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewStartPacketGeneratorParamsWithContext 

func NewStartPacketGeneratorParamsWithContext(ctx context.Context) *StartPacketGeneratorParams

NewStartPacketGeneratorParamsWithContext creates a new StartPacketGeneratorParams object with the ability to set a context for a request.

func NewStartPacketGeneratorParamsWithHTTPClient 

func NewStartPacketGeneratorParamsWithHTTPClient(client *http.Client) *StartPacketGeneratorParams

NewStartPacketGeneratorParamsWithHTTPClient creates a new StartPacketGeneratorParams object with the ability to set a custom HTTPClient for a request.

func NewStartPacketGeneratorParamsWithTimeout 

func NewStartPacketGeneratorParamsWithTimeout(timeout time.Duration) *StartPacketGeneratorParams

NewStartPacketGeneratorParamsWithTimeout creates a new StartPacketGeneratorParams object with the ability to set a timeout on a request.

func (*StartPacketGeneratorParams) SetContext 

func (o *StartPacketGeneratorParams) SetContext(ctx context.Context)

SetContext adds the context to the start packet generator params

func (*StartPacketGeneratorParams) SetDefaults 

func (o *StartPacketGeneratorParams) SetDefaults()

SetDefaults hydrates default values in the start packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*StartPacketGeneratorParams) SetHTTPClient 

func (o *StartPacketGeneratorParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the start packet generator params

func (*StartPacketGeneratorParams) SetID 

func (o *StartPacketGeneratorParams) SetID(id string)

SetID adds the id to the start packet generator params

func (*StartPacketGeneratorParams) SetTimeout 

func (o *StartPacketGeneratorParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the start packet generator params

func (*StartPacketGeneratorParams) WithContext 

func (o *StartPacketGeneratorParams) WithContext(ctx context.Context) *StartPacketGeneratorParams

WithContext adds the context to the start packet generator params

func (*StartPacketGeneratorParams) WithDefaults 

func (o *StartPacketGeneratorParams) WithDefaults() *StartPacketGeneratorParams

WithDefaults hydrates default values in the start packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*StartPacketGeneratorParams) WithHTTPClient 

func (o *StartPacketGeneratorParams) WithHTTPClient(client *http.Client) *StartPacketGeneratorParams

WithHTTPClient adds the HTTPClient to the start packet generator params

func (*StartPacketGeneratorParams) WithID 

func (o *StartPacketGeneratorParams) WithID(id string) *StartPacketGeneratorParams

WithID adds the id to the start packet generator params

func (*StartPacketGeneratorParams) WithTimeout 

func (o *StartPacketGeneratorParams) WithTimeout(timeout time.Duration) *StartPacketGeneratorParams

WithTimeout adds the timeout to the start packet generator params

func (*StartPacketGeneratorParams) WriteToRequest 

func (o *StartPacketGeneratorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type StartPacketGeneratorReader 

type StartPacketGeneratorReader struct {
	// contains filtered or unexported fields
}

StartPacketGeneratorReader is a Reader for the StartPacketGenerator structure.

func (*StartPacketGeneratorReader) ReadResponse 

func (o *StartPacketGeneratorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type StopPacketGeneratorNoContent 

type StopPacketGeneratorNoContent struct {
}
StopPacketGeneratorNoContent describes a response with status code 204, with default header values.

No Content

func NewStopPacketGeneratorNoContent 

func NewStopPacketGeneratorNoContent() *StopPacketGeneratorNoContent

NewStopPacketGeneratorNoContent creates a StopPacketGeneratorNoContent with default headers values

func (*StopPacketGeneratorNoContent) Error 

func (o *StopPacketGeneratorNoContent) Error() string

type StopPacketGeneratorParams 

type StopPacketGeneratorParams struct {

	/* ID.

	   Unique resource identifier

	   Format: string
	*/
	ID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

StopPacketGeneratorParams contains all the parameters to send to the API endpoint 

for the stop packet generator operation.

Typically these are written to a http.Request.

func NewStopPacketGeneratorParams 

func NewStopPacketGeneratorParams() *StopPacketGeneratorParams

NewStopPacketGeneratorParams creates a new StopPacketGeneratorParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewStopPacketGeneratorParamsWithContext 

func NewStopPacketGeneratorParamsWithContext(ctx context.Context) *StopPacketGeneratorParams

NewStopPacketGeneratorParamsWithContext creates a new StopPacketGeneratorParams object with the ability to set a context for a request.

func NewStopPacketGeneratorParamsWithHTTPClient 

func NewStopPacketGeneratorParamsWithHTTPClient(client *http.Client) *StopPacketGeneratorParams

NewStopPacketGeneratorParamsWithHTTPClient creates a new StopPacketGeneratorParams object with the ability to set a custom HTTPClient for a request.

func NewStopPacketGeneratorParamsWithTimeout 

func NewStopPacketGeneratorParamsWithTimeout(timeout time.Duration) *StopPacketGeneratorParams

NewStopPacketGeneratorParamsWithTimeout creates a new StopPacketGeneratorParams object with the ability to set a timeout on a request.

func (*StopPacketGeneratorParams) SetContext 

func (o *StopPacketGeneratorParams) SetContext(ctx context.Context)

SetContext adds the context to the stop packet generator params

func (*StopPacketGeneratorParams) SetDefaults 

func (o *StopPacketGeneratorParams) SetDefaults()

SetDefaults hydrates default values in the stop packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*StopPacketGeneratorParams) SetHTTPClient 

func (o *StopPacketGeneratorParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the stop packet generator params

func (*StopPacketGeneratorParams) SetID 

func (o *StopPacketGeneratorParams) SetID(id string)

SetID adds the id to the stop packet generator params

func (*StopPacketGeneratorParams) SetTimeout 

func (o *StopPacketGeneratorParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the stop packet generator params

func (*StopPacketGeneratorParams) WithContext 

func (o *StopPacketGeneratorParams) WithContext(ctx context.Context) *StopPacketGeneratorParams

WithContext adds the context to the stop packet generator params

func (*StopPacketGeneratorParams) WithDefaults 

func (o *StopPacketGeneratorParams) WithDefaults() *StopPacketGeneratorParams

WithDefaults hydrates default values in the stop packet generator params (not the query body).

All values with no default are reset to their zero value.

func (*StopPacketGeneratorParams) WithHTTPClient 

func (o *StopPacketGeneratorParams) WithHTTPClient(client *http.Client) *StopPacketGeneratorParams

WithHTTPClient adds the HTTPClient to the stop packet generator params

func (*StopPacketGeneratorParams) WithID 

func (o *StopPacketGeneratorParams) WithID(id string) *StopPacketGeneratorParams

WithID adds the id to the stop packet generator params

func (*StopPacketGeneratorParams) WithTimeout 

func (o *StopPacketGeneratorParams) WithTimeout(timeout time.Duration) *StopPacketGeneratorParams

WithTimeout adds the timeout to the stop packet generator params

func (*StopPacketGeneratorParams) WriteToRequest 

func (o *StopPacketGeneratorParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type StopPacketGeneratorReader 

type StopPacketGeneratorReader struct {
	// contains filtered or unexported fields
}

StopPacketGeneratorReader is a Reader for the StopPacketGenerator structure.

func (*StopPacketGeneratorReader) ReadResponse 

func (o *StopPacketGeneratorReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type TogglePacketGeneratorsBody 

type TogglePacketGeneratorsBody struct {

	// The unique id of the running generator
	// Required: true
	Replace *string `json:"replace"`

	// The unique id of the stopped generator
	// Required: true
	With *string `json:"with"`
}

TogglePacketGeneratorsBody TogglePacketGeneratorsRequest // // Parameters for the toggle operation swagger:model TogglePacketGeneratorsBody

func (*TogglePacketGeneratorsBody) ContextValidate 

func (o *TogglePacketGeneratorsBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this toggle packet generators body based on context it is used

func (*TogglePacketGeneratorsBody) MarshalBinary 

func (o *TogglePacketGeneratorsBody) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TogglePacketGeneratorsBody) UnmarshalBinary 

func (o *TogglePacketGeneratorsBody) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TogglePacketGeneratorsBody) Validate 

func (o *TogglePacketGeneratorsBody) Validate(formats strfmt.Registry) error

Validate validates this toggle packet generators body

type TogglePacketGeneratorsCreated 

type TogglePacketGeneratorsCreated struct {

	/* URI to created generator result object
	 */
	Location string

	Payload *models.PacketGeneratorResult
}
TogglePacketGeneratorsCreated describes a response with status code 201, with default header values.

Created

func NewTogglePacketGeneratorsCreated 

func NewTogglePacketGeneratorsCreated() *TogglePacketGeneratorsCreated

NewTogglePacketGeneratorsCreated creates a TogglePacketGeneratorsCreated with default headers values

func (*TogglePacketGeneratorsCreated) Error 

func (o *TogglePacketGeneratorsCreated) Error() string

func (*TogglePacketGeneratorsCreated) GetPayload 

func (o *TogglePacketGeneratorsCreated) GetPayload() *models.PacketGeneratorResult

type TogglePacketGeneratorsParams 

type TogglePacketGeneratorsParams struct {

	/* Toggle.

	   Generator toggle
	*/
	Toggle TogglePacketGeneratorsBody

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

TogglePacketGeneratorsParams contains all the parameters to send to the API endpoint 

for the toggle packet generators operation.

Typically these are written to a http.Request.

func NewTogglePacketGeneratorsParams 

func NewTogglePacketGeneratorsParams() *TogglePacketGeneratorsParams

NewTogglePacketGeneratorsParams creates a new TogglePacketGeneratorsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewTogglePacketGeneratorsParamsWithContext 

func NewTogglePacketGeneratorsParamsWithContext(ctx context.Context) *TogglePacketGeneratorsParams

NewTogglePacketGeneratorsParamsWithContext creates a new TogglePacketGeneratorsParams object with the ability to set a context for a request.

func NewTogglePacketGeneratorsParamsWithHTTPClient 

func NewTogglePacketGeneratorsParamsWithHTTPClient(client *http.Client) *TogglePacketGeneratorsParams

NewTogglePacketGeneratorsParamsWithHTTPClient creates a new TogglePacketGeneratorsParams object with the ability to set a custom HTTPClient for a request.

func NewTogglePacketGeneratorsParamsWithTimeout 

func NewTogglePacketGeneratorsParamsWithTimeout(timeout time.Duration) *TogglePacketGeneratorsParams

NewTogglePacketGeneratorsParamsWithTimeout creates a new TogglePacketGeneratorsParams object with the ability to set a timeout on a request.

func (*TogglePacketGeneratorsParams) SetContext 

func (o *TogglePacketGeneratorsParams) SetContext(ctx context.Context)

SetContext adds the context to the toggle packet generators params

func (*TogglePacketGeneratorsParams) SetDefaults 

func (o *TogglePacketGeneratorsParams) SetDefaults()

SetDefaults hydrates default values in the toggle packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*TogglePacketGeneratorsParams) SetHTTPClient 

func (o *TogglePacketGeneratorsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the toggle packet generators params

func (*TogglePacketGeneratorsParams) SetTimeout 

func (o *TogglePacketGeneratorsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the toggle packet generators params

func (*TogglePacketGeneratorsParams) SetToggle 

func (o *TogglePacketGeneratorsParams) SetToggle(toggle TogglePacketGeneratorsBody)

SetToggle adds the toggle to the toggle packet generators params

func (*TogglePacketGeneratorsParams) WithContext 

func (o *TogglePacketGeneratorsParams) WithContext(ctx context.Context) *TogglePacketGeneratorsParams

WithContext adds the context to the toggle packet generators params

func (*TogglePacketGeneratorsParams) WithDefaults 

func (o *TogglePacketGeneratorsParams) WithDefaults() *TogglePacketGeneratorsParams

WithDefaults hydrates default values in the toggle packet generators params (not the query body).

All values with no default are reset to their zero value.

func (*TogglePacketGeneratorsParams) WithHTTPClient 

func (o *TogglePacketGeneratorsParams) WithHTTPClient(client *http.Client) *TogglePacketGeneratorsParams

WithHTTPClient adds the HTTPClient to the toggle packet generators params

func (*TogglePacketGeneratorsParams) WithTimeout 

func (o *TogglePacketGeneratorsParams) WithTimeout(timeout time.Duration) *TogglePacketGeneratorsParams

WithTimeout adds the timeout to the toggle packet generators params

func (*TogglePacketGeneratorsParams) WithToggle 

func (o *TogglePacketGeneratorsParams) WithToggle(toggle TogglePacketGeneratorsBody) *TogglePacketGeneratorsParams

WithToggle adds the toggle to the toggle packet generators params

func (*TogglePacketGeneratorsParams) WriteToRequest 

func (o *TogglePacketGeneratorsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type TogglePacketGeneratorsReader 

type TogglePacketGeneratorsReader struct {
	// contains filtered or unexported fields
}

TogglePacketGeneratorsReader is a Reader for the TogglePacketGenerators structure.

func (*TogglePacketGeneratorsReader) ReadResponse 

func (o *TogglePacketGeneratorsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.