voc

Documentation

Overview

Package voc contains the vocabulary for Cloud resources and their properties that can be discovered using Clouditor

Index

• Variables
• func ToStruct(r IsCloudResource) (s *structpb.Value, err error)
• type ABAC
  • func (*ABAC) Type() string
• type AccessRestriction
  • func (*AccessRestriction) Type() string
• type Account
• type ActivityLogging
• type AnomalyDetection
• type Application
• type ApplicationLogging
• type AtRestEncryption
  • func (a *AtRestEncryption) IsEnabled() bool
  • func (*AtRestEncryption) Type() string
• type Auditing
• type Authenticity
• type Authorization
• type AutomaticUpdates
• type Availability
• type Backup
• type BlockStorage
• type BootLogging
• type CICDService
• type CertificateBasedAuthentication
  • func (*CertificateBasedAuthentication) Type() string
• type CloudResourceGroup
• type CloudSDK
• type Compute
• type Confidentiality
• type Container
• type ContainerImage
• type ContainerOrchestration
• type ContainerRegistry
• type CustomerKeyEncryption
  • func (*CustomerKeyEncryption) Type() string
• type DDoSProtection
• type DatabaseConnect
• type DatabaseOperation
• type DatabaseQuery
• type DatabaseService
• type DatabaseStorage
• type DeviceProvisioningService
• type DocumentDatabaseService
• type FileStorage
• type Framework
• type Function
• type Functionality
• type GeoLocation
• type HasHttpEndpoint
• type HttpClientLibrary
• type HttpEndpoint
• type HttpRequest
• type HttpRequestHandler
• type HttpServer
• type Identifiable
• type Identity
• type Image
• type Immutability
• type Integrity
• type IoT
• type IsAtRestEncryption
• type IsAuthenticity
• type IsAuthorization
• type IsCloudResource
• type IsCompute
• type IsNetwork
• type IsSecurityFeature
• type IsStorage
• type Job
• type KeyValueDatabaseService
• type L3Firewall
• type LoadBalancer
• type LogOperation
• type Logger
• type Logging
• type LoggingService
  • func (l LoggingService) Related() []string
• type MalwareProtection
• type ManagedKeyEncryption
  • func (*ManagedKeyEncryption) Type() string
• type MessagingHub
• type NetworkInterface
• type NetworkSecurityGroup
• type NetworkService
• type Networking
• type NoAuthentication
  • func (*NoAuthentication) Type() string
• type OSLogging
• type OTPBasedAuthentication
  • func (*OTPBasedAuthentication) Type() string
• type ObjectStorage
• type ObjectStorageRequest
• type ObjectStorageService
• type Operation
• type PasswordBasedAuthentication
  • func (*PasswordBasedAuthentication) Type() string
• type PasswordPolicy
• type ProxiedEndpoint
• type RBAC
  • func (*RBAC) Type() string
• type RelationalDatabaseService
• type Resource
  • func (r *Resource) GetCreationTime() *time.Time
  • func (r *Resource) GetID() ResourceID
  • func (r *Resource) GetName() string
  • func (r *Resource) GetServiceID() string
  • func (r *Resource) GetType() []string
  • func (r *Resource) HasType(resourceType string) (ok bool)
  • func (*Resource) Related() []string
  • func (r *Resource) SetServiceID(ID string)
• type ResourceID
• type ResourceLogging
• type RoleAssignment
• type SecurityFeature
• type SingleSignOn
  • func (*SingleSignOn) Type() string
• type Storage
• type StorageService
• type TokenBasedAuthentication
  • func (*TokenBasedAuthentication) Type() string
• type TransportEncryption
  • func (*TransportEncryption) Type() string
• type VMImage
• type VirtualMachine
  • func (v VirtualMachine) Related() []string
• type VirtualNetwork
• type VirtualSubNetwork
• type WebApplicationFirewall
• type Workflow

Variables

var AccountType = []string{"Account", "Resource"}

var BlockStorageType = []string{"BlockStorage", "Storage", "Resource"}

var CICDServiceType = []string{"CI/CD Service", "Resource"}

var ComputeType = []string{"Compute", "Resource"}

var ContainerImageType = []string{"Container Image", "Image", "Resource"}

var ContainerOrchestrationType = []string{"ContainerOrchestration", "Resource"}

var ContainerRegistryType = []string{"ContainerRegistry", "Resource"}

var ContainerType = []string{"Container", "Compute", "Resource"}

var DatabaseServiceType = []string{"DatabaseService", "StorageService", "NetworkService", "Networking", "Resource"}

var DatabaseStorageType = []string{"DatabaseStorage", "Storage", "Resource"}

var DeviceProvisioningServiceType = []string{"DeviceProvisioningService", "IoT", "Resource"}

var DocumentDatabaseServiceType = []string{"DocumentDatabaseService", "DatabaseService", "StorageService", "NetworkService", "Networking", "Resource"}

var FileStorageType = []string{"FileStorage", "Storage", "Resource"}

var FunctionType = []string{"Function", "Compute", "Resource"}

var IdentifiableType = []string{"Identifiable", "Resource"}

var IdentityType = []string{"Identity", "Identifiable", "Resource"}

var ImageType = []string{"Image", "Resource"}

var IoTType = []string{"IoT", "Resource"}

var JobType = []string{"Job", "CI/CD Service", "Resource"}

var KeyValueDatabaseServiceType = []string{"KeyValueDatabaseService", "DatabaseService", "StorageService", "NetworkService", "Networking", "Resource"}

var LoadBalancerType = []string{"LoadBalancer", "NetworkService", "Networking", "Resource"}

var LoggingServiceType = []string{"LoggingService", "NetworkService", "Networking", "Resource"}

var MessagingHubType = []string{"MessagingHub", "IoT", "Resource"}

var NetworkInterfaceType = []string{"NetworkInterface", "Networking", "Resource"}

var NetworkSecurityGroupType = []string{"NetworkSecurityGroup", "Networking", "Resource"}

var NetworkServiceType = []string{"NetworkService", "Networking", "Resource"}

var NetworkingType = []string{"Networking", "Resource"}

var ObjectStorageServiceType = []string{"ObjectStorageService", "StorageService", "NetworkService", "Networking", "Resource"}

var ObjectStorageType = []string{"ObjectStorage", "Storage", "Resource"}

var PasswordPolicyType = []string{"PasswordPolicy", "Resource"}

var RelationalDatabaseServiceType = []string{"RelationalDatabaseService", "DatabaseService", "StorageService", "NetworkService", "Networking", "Resource"}

var RoleAssignmentType = []string{"RoleAssignment", "Identifiable", "Resource"}

var StorageServiceType = []string{"StorageService", "NetworkService", "Networking", "Resource"}

var StorageType = []string{"Storage", "Resource"}

var VMImageType = []string{"VM Image", "Image", "Resource"}

var VirtualMachineType = []string{"VirtualMachine", "Compute", "Resource"}

var VirtualNetworkType = []string{"VirtualNetwork", "Networking", "Resource"}

var VirtualSubNetworkType = []string{"VirtualSubNetwork", "Networking", "Resource"}

var WorkflowType = []string{"Workflow", "CI/CD Service", "Resource"}

Functions

func ToStruct

func ToStruct(r IsCloudResource) (s *structpb.Value, err error)

Types

type ABAC

type ABAC struct {
	*Authorization
}

func (*ABAC) Type

func (*ABAC) Type() string

type AccessRestriction

type AccessRestriction struct {
	*Authorization
}

func (*AccessRestriction) Type

func (*AccessRestriction) Type() string

type Account

type Account struct {
	*Resource
}

Account is an entity in our Cloud ontology. This represents the cloud account as a whole, e.g., an Azure subscription.

type ActivityLogging

type ActivityLogging struct {
	*Logging
}

type AnomalyDetection

type AnomalyDetection struct {
	*Auditing
	ApplicationLogging *ApplicationLogging `json:"applicationLogging"`
	Enabled            bool                `json:"enabled"`
}

AnomalyDetection is an entity in our Cloud ontology. analyzes the activity of a NetworkService (which includes DatabaseServices)

type Application

type Application struct {
	Functionalities     *[]Functionality `json:"functionalities"`
	Compute             []ResourceID     `json:"compute"`
	ProgrammingLanguage string           `json:"programmingLanguage"`
	TranslationUnits    []string         `json:"translationUnits"`
}

Application is an entity in our Cloud ontology. This encapsulates the whole (source) code of an application.

type ApplicationLogging

type ApplicationLogging struct {
	*Logging
}

type AtRestEncryption

type AtRestEncryption struct {
	*Confidentiality
	Algorithm string `json:"algorithm"`
	Enabled   bool   `json:"enabled"`
}

func (*AtRestEncryption) IsEnabled

func (a *AtRestEncryption) IsEnabled() bool

func (*AtRestEncryption) Type

func (*AtRestEncryption) Type() string

type Auditing

type Auditing struct {
	*SecurityFeature
}

type Authenticity

type Authenticity struct {
	*SecurityFeature
}

type Authorization

type Authorization struct {
	*SecurityFeature
}

type AutomaticUpdates

type AutomaticUpdates struct {
	*Integrity
	Enabled      bool `json:"enabled"`
	SecurityOnly bool `json:"securityOnly"`
	// The interval refers to the update interval in days.
	Interval time.Duration `json:"interval"`
}

AutomaticUpdates is an entity in our Cloud ontology. This feature is, e.g., available on some VM services to automatically update their software. It ensures that a resource is protected from tampering with its state.

type Availability

type Availability struct {
	*SecurityFeature
}

type Backup

type Backup struct {
	*Availability
	RetentionPeriod time.Duration `json:"retentionPeriod"`
	Enabled         bool          `json:"enabled"`
	Policy          string        `json:"policy"`
}

type BlockStorage

type BlockStorage struct {
	*Storage
}

type BootLogging

type BootLogging struct {
	*Logging
}

type CICDService

type CICDService struct {
	*Resource
}

type CertificateBasedAuthentication

type CertificateBasedAuthentication struct {
	*Authenticity
	Enabled bool `json:"enabled"`
}

func (*CertificateBasedAuthentication) Type

func (*CertificateBasedAuthentication) Type() string

type CloudResourceGroup

type CloudResourceGroup struct {
	Resources *[]Resource `json:"resources"`
}

type CloudSDK

type CloudSDK struct {
	*Framework
}

type Compute

type Compute struct {
	*Resource
	NetworkInterfaces []ResourceID `json:"networkInterfaces"`
}

type Confidentiality

type Confidentiality struct {
	*SecurityFeature
}

type Container

type Container struct {
	*Compute
	Image ResourceID `json:"image"`
}

type ContainerImage

type ContainerImage struct {
	*Image
}

type ContainerOrchestration

type ContainerOrchestration struct {
	*Resource
	ResourceLogging *ResourceLogging `json:"resourceLogging"`
	Containers      []ResourceID     `json:"containers"`
	ManagementUrl   string           `json:"managementUrl"`
}

type ContainerRegistry

type ContainerRegistry struct {
	*Resource
}

type CustomerKeyEncryption

type CustomerKeyEncryption struct {
	*AtRestEncryption
	KeyUrl string `json:"keyUrl"`
}

func (*CustomerKeyEncryption) Type

func (*CustomerKeyEncryption) Type() string

type DDoSProtection

type DDoSProtection struct {
	*Availability
}

type DatabaseConnect

type DatabaseConnect struct {
	*DatabaseOperation
}

type DatabaseOperation

type DatabaseOperation struct {
	*Operation
	Storage         []ResourceID `json:"storage"`
	DatabaseService []ResourceID `json:"databaseService"`
	Calls           []string     `json:"calls"`
}

type DatabaseQuery

type DatabaseQuery struct {
	*DatabaseOperation
	Modify bool `json:"modify"`
}

type DatabaseService

type DatabaseService struct {
	*StorageService
}

DatabaseService is an entity in our Cloud ontology. This class represents a database service. For example, a postgres SQL server would be modelled as a database service (with a host and IP) and the individual tables or collections would be modelled as a DatabaseStorage entity.

type DatabaseStorage

type DatabaseStorage struct {
	*Storage
	Parent []ResourceID `json:"parent"`
}

DatabaseStorage is an entity in our Cloud ontology. describes the actual database or a table in a database

type DeviceProvisioningService

type DeviceProvisioningService struct {
	*IoT
}

type DocumentDatabaseService

type DocumentDatabaseService struct {
	*DatabaseService
}

type FileStorage

type FileStorage struct {
	*Storage
}

type Framework

type Framework struct {
}

type Function

type Function struct {
	*Compute
	RuntimeVersion  string `json:"runtimeVersion"`
	RuntimeLanguage string `json:"runtimeLanguage"`
}

type Functionality

type Functionality struct {
}

type GeoLocation

type GeoLocation struct {
	*Availability
	Region string `json:"region"`
}

type HasHttpEndpoint

type HasHttpEndpoint interface {
	GetHttpEndpoint() *HttpEndpoint
}

type HttpClientLibrary

type HttpClientLibrary struct {
	*Framework
}

type HttpEndpoint

type HttpEndpoint struct {
	*Functionality
	Authenticity        IsAuthenticity       `json:"authenticity"`
	TransportEncryption *TransportEncryption `json:"transportEncryption"`
	Url                 string               `json:"url"`
	Method              string               `json:"method"`
	Handler             string               `json:"handler"`
	Path                string               `json:"path"`
}

HttpEndpoint is an entity in our Cloud ontology. Via the Authenticity relationship, the access type can be specified, e.g. public access (no authentication), password-based, etc.

type HttpRequest

type HttpRequest struct {
	*Operation
	HttpEndpoint *HttpEndpoint `json:"httpEndpoint"`
	Call         string        `json:"call"`
	ReqBody      string        `json:"reqBody"`
}

type HttpRequestHandler

type HttpRequestHandler struct {
	*Functionality
	Application   *Application    `json:"application"`
	HttpEndpoints *[]HttpEndpoint `json:"httpEndpoints"`
	Path          string          `json:"path"`
}

type HttpServer

type HttpServer struct {
	*Framework
	HttpRequestHandler *HttpRequestHandler `json:"httpRequestHandler"`
}

type Identifiable

type Identifiable struct {
	*Resource
	Authenticity  IsAuthenticity  `json:"authenticity"`
	Authorization IsAuthorization `json:"authorization"`
	Activated     bool            `json:"activated"`
}

type Identity

type Identity struct {
	*Identifiable
	Authenticities        []IsAuthenticity `json:"authenticities"`
	Privileged            bool             `json:"privileged"`
	LastActivity          time.Time        `json:"lastActivity"`
	DisablePasswordPolicy bool             `json:"disablePasswordPolicy"`
}

type Image

type Image struct {
	*Resource
	Application *Application `json:"application"`
}

type Immutability

type Immutability struct {
	*Integrity
	Enabled bool `json:"enabled"`
}

type Integrity

type Integrity struct {
	*SecurityFeature
}

type IoT

type IoT struct {
	*Resource
}

type IsAtRestEncryption

type IsAtRestEncryption interface {
	IsSecurityFeature

	IsEnabled() bool
	// contains filtered or unexported methods
}

type IsAuthenticity

type IsAuthenticity interface {
	IsSecurityFeature
	// contains filtered or unexported methods
}

type IsAuthorization

type IsAuthorization interface {
	IsSecurityFeature
	// contains filtered or unexported methods
}

type IsCloudResource

type IsCloudResource interface {
	GetID() ResourceID
	GetServiceID() string
	SetServiceID(ID string)
	GetName() string
	GetType() []string
	HasType(string) bool
	GetCreationTime() *time.Time
	Related() []string
}

type IsCompute

type IsCompute interface {
	IsCloudResource
}

type IsNetwork

type IsNetwork interface {
	IsCloudResource
}

type IsSecurityFeature

type IsSecurityFeature interface {
	Type() string
}

type IsStorage

type IsStorage interface {
	IsCloudResource
	IsAtRestEncryption
}

type Job

type Job struct {
	*CICDService
}

type KeyValueDatabaseService

type KeyValueDatabaseService struct {
	*DatabaseService
}

type L3Firewall

type L3Firewall struct {
	*AccessRestriction
	Inbound         bool   `json:"inbound"`
	Enabled         bool   `json:"enabled"`
	RestrictedPorts string `json:"restrictedPorts"`
}

type LoadBalancer

type LoadBalancer struct {
	*NetworkService
	AccessRestrictions *[]AccessRestriction `json:"accessRestrictions"`
	HttpEndpoints      *[]HttpEndpoint      `json:"httpEndpoints"`
	NetworkServices    []ResourceID         `json:"networkServices"`
	Url                string               `json:"url"`
}

LoadBalancer is an entity in our Cloud ontology. A Load Balancer may have multiple access restriction features, e.g. a L3 firewall and a WAF

type LogOperation

type LogOperation struct {
	*Operation
	Logging *Logging `json:"logging"`
	Call    string   `json:"call"`
	Value   string   `json:"value"`
}

LogOperation is an entity in our Cloud ontology. A LogOperation is used by an application

type Logger

type Logger struct {
	*Framework
}

type Logging

type Logging struct {
	*Auditing
	LoggingService  []ResourceID  `json:"loggingService"`
	Enabled         bool          `json:"enabled"`
	RetentionPeriod time.Duration `json:"retentionPeriod"`
}

type LoggingService

type LoggingService struct {
	*NetworkService
	Storage []ResourceID `json:"storage"`
}

LoggingService is an entity in our Cloud ontology. A logging-as-a-service offering, e.g. for analyzing logs; has a Storage resource that stores the logs

func (LoggingService) Related

func (l LoggingService) Related() []string

Related returns related resources for the logging service, e.g., its storage.

type MalwareProtection

type MalwareProtection struct {
	*Auditing
	ApplicationLogging   *ApplicationLogging `json:"applicationLogging"`
	DaysSinceActive      time.Duration       `json:"daysSinceActive"`
	NumberOfThreatsFound int                 `json:"numberOfThreatsFound"`
	Enabled              bool                `json:"enabled"`
}

MalwareProtection is an entity in our Cloud ontology. analyzes the activity within a Compute resource

type ManagedKeyEncryption

type ManagedKeyEncryption struct {
	*AtRestEncryption
}

func (*ManagedKeyEncryption) Type

func (*ManagedKeyEncryption) Type() string

type MessagingHub

type MessagingHub struct {
	*IoT
}

type NetworkInterface

type NetworkInterface struct {
	*Networking
	NetworkService    ResourceID         `json:"networkService"`
	AccessRestriction *AccessRestriction `json:"accessRestriction"`
}

type NetworkSecurityGroup

type NetworkSecurityGroup struct {
	*Networking
}

type NetworkService

type NetworkService struct {
	*Networking
	Authenticity        IsAuthenticity       `json:"authenticity"`
	Compute             ResourceID           `json:"compute"`
	TransportEncryption *TransportEncryption `json:"transportEncryption"`
	Ips                 []string             `json:"ips"`
	Ports               []uint16             `json:"ports"`
}

NetworkService is an entity in our Cloud ontology. A NetworkService is an application (on the network layer) running on a Compute resource. It provides access to a resource

type Networking

type Networking struct {
	*Resource
}

type NoAuthentication

type NoAuthentication struct {
	*Authenticity
}

func (*NoAuthentication) Type

func (*NoAuthentication) Type() string

type OSLogging

type OSLogging struct {
	*Logging
}

type OTPBasedAuthentication

type OTPBasedAuthentication struct {
	*Authenticity
	Activated bool `json:"activated"`
}

func (*OTPBasedAuthentication) Type

func (*OTPBasedAuthentication) Type() string

type ObjectStorage

type ObjectStorage struct {
	*Storage
	// TODO(oxisto): This is a little bit of a hack. We actually want to use
	// Authenticity for determining public access, but this is currently not
	// possible since Authenticity is only on the StorageService. But in Azure,
	// a StorageService is only created for the storage account, not the
	// individual container.
	PublicAccess bool `json:"publicAccess"`
}

type ObjectStorageRequest

type ObjectStorageRequest struct {
	*Operation
	ObjectStorage []ResourceID `json:"objectStorage"`
	Source        string       `json:"source"`
	Type          string       `json:"type"`
}

type ObjectStorageService

type ObjectStorageService struct {
	*StorageService
	HttpEndpoint *HttpEndpoint `json:"httpEndpoint"`
}

ObjectStorageService is an entity in our Cloud ontology. An object storage service represents the network service that is used to access a list of object storage containers. The storage itself is modelled as a ObjectStorage. The service has an http endpoint.

type Operation

type Operation struct {
	*Functionality
}

type PasswordBasedAuthentication

type PasswordBasedAuthentication struct {
	*Authenticity
	Activated bool `json:"activated"`
}

func (*PasswordBasedAuthentication) Type

func (*PasswordBasedAuthentication) Type() string

type PasswordPolicy

type PasswordPolicy struct {
	*Resource
}

type ProxiedEndpoint

type ProxiedEndpoint struct {
	*HttpEndpoint
	ProxyTarget *HttpEndpoint `json:"proxyTarget"`
}

ProxiedEndpoint is an entity in our Cloud ontology. An HTTP endpoint, that is routed through a (reverse) proxy, e.g. a load balancer.

type RBAC

type RBAC struct {
	*Authorization
	// see Privacy Smells: Detecting Privacy Problems in Cloud Architectures (2020)
	MixedDuties float32 `json:"mixedDuties"`
	// see Privacy Smells: Detecting Privacy Problems in Cloud Architectures (2020)
	BroadAssignments float32 `json:"broadAssignments"`
}

func (*RBAC) Type

func (*RBAC) Type() string

type RelationalDatabaseService

type RelationalDatabaseService struct {
	*DatabaseService
}

type Resource

type Resource struct {
	ID ResourceID `json:"id"`
	// ServiceID contains the ID of the cloud service to which this resource belongs. When creating new resources using
	// the NewResource function of the discovery API, this gets filled automatically.
	ServiceID    string `json:"serviceId"`
	Name         string `json:"name"`
	CreationTime int64  `json:"creationTime"` // is set to 0 if no creation time is available
	// The resource type. It is an array, because a type can be derived from another
	Type        []string          `json:"type"`
	GeoLocation GeoLocation       `json:"geoLocation"`
	Labels      map[string]string `json:"labels"`
}

Resource file from Ontology currently not used. How do we merge this file with the 'Resource Ontology file'

func (*Resource) GetCreationTime

func (r *Resource) GetCreationTime() *time.Time

func (*Resource) GetID

func (r *Resource) GetID() ResourceID

func (*Resource) GetName

func (r *Resource) GetName() string

func (*Resource) GetServiceID

func (r *Resource) GetServiceID() string

func (*Resource) GetType

func (r *Resource) GetType() []string

func (*Resource) HasType

func (r *Resource) HasType(resourceType string) (ok bool)

HasType checks whether the resource has the particular resourceType

func (*Resource) Related

func (*Resource) Related() []string

func (*Resource) SetServiceID

func (r *Resource) SetServiceID(ID string)

type ResourceID

type ResourceID string

type ResourceLogging

type ResourceLogging struct {
	*Logging
}

type RoleAssignment

type RoleAssignment struct {
	*Identifiable
}

type SecurityFeature

type SecurityFeature struct {
}

type SingleSignOn

type SingleSignOn struct {
	*Authenticity
	Enabled bool `json:"enabled"`
}

func (*SingleSignOn) Type

func (*SingleSignOn) Type() string

type Storage

type Storage struct {
	*Resource
	AtRestEncryption IsAtRestEncryption `json:"atRestEncryption"`
	Immutability     *Immutability      `json:"immutability"`
}

type StorageService

type StorageService struct {
	*NetworkService
	Storage []ResourceID `json:"storage"`
}

StorageService is an entity in our Cloud ontology. This entity represents a network-based service that can be used to access a particular storage backend. It has multiple subclasses, e.g., for databases or object stores. It has a list of storage resources associated to it.

type TokenBasedAuthentication

type TokenBasedAuthentication struct {
	*Authenticity
	Enforced  bool `json:"enforced"`
	Activated bool `json:"activated"`
}

func (*TokenBasedAuthentication) Type

func (*TokenBasedAuthentication) Type() string

type TransportEncryption

type TransportEncryption struct {
	*Confidentiality
	Enforced   bool   `json:"enforced"`
	Enabled    bool   `json:"enabled"`
	TlsVersion string `json:"tlsVersion"`
	Algorithm  string `json:"algorithm"`
}

TransportEncryption is an entity in our Cloud ontology. enabled means the resource _can_ be reached via https, while enforced means it _can only_ be reached via https (or http traffic is redirected)

func (*TransportEncryption) Type

func (*TransportEncryption) Type() string

type VMImage

type VMImage struct {
	*Image
}

type VirtualMachine

type VirtualMachine struct {
	*Compute
	BlockStorage      []ResourceID       `json:"blockStorage"`
	AutomaticUpdates  *AutomaticUpdates  `json:"automaticUpdates"`
	BootLogging       *BootLogging       `json:"bootLogging"`
	MalwareProtection *MalwareProtection `json:"malwareProtection"`
	OsLogging         *OSLogging         `json:"osLogging"`
}

func (VirtualMachine) Related

func (v VirtualMachine) Related() []string

Related returns related resources for the virtual machine, e.g., its attached storage and network interfaces.

type VirtualNetwork

type VirtualNetwork struct {
	*Networking
}

type VirtualSubNetwork

type VirtualSubNetwork struct {
	*Networking
}

type WebApplicationFirewall

type WebApplicationFirewall struct {
	*AccessRestriction
	Enabled bool `json:"enabled"`
}

WebApplicationFirewall is an entity in our Cloud ontology. A WAF is a L7 firewall that includes L3 capabilities

type Workflow

type Workflow struct {
	*CICDService
}