v1alpha2

type ContainerStartupOpts struct {
	// URL from which GET the archive to be extracted into ContentPath
	SourceArchiveURL string `json:"sourceArchiveURL,omitempty"`
	// Path on which storage (EmptyDir/Storage) will be mounted
	// and into which, if given in SourceArchiveURL, will be extracted the archive
	ContentPath string `json:"contentPath,omitempty"`
	// Arguments to be passed to the application container on startup
	StartupArgs []string `json:"startupArgs,omitempty"`
	// Whether forcing the container working directory to be the same as the contentPath (or default mydrive path if not specified)
	// +kubebuilder:validation:Optional
	// +kubebuilder:default=false
	EnforceWorkdir bool `json:"enforceWorkdir"`
}

type Environment struct {
	// The name identifying the specific environment.
	Name string `json:"name"`

	// The VM or container to be started when instantiating the environment.
	Image string `json:"image"`

	// The type of environment to be instantiated, among VirtualMachine,
	// Container, CloudVM and Standalone.
	EnvironmentType EnvironmentType `json:"environmentType"`

	// Whether the environment is characterized by a graphical desktop or not.
	GuiEnabled bool `json:"guiEnabled,omitempty"`

	// For VNC based containers, hide the noVNC control bar when true
	DisableControls bool `json:"disableControls,omitempty"`

	// Whether the environment should be persistent (i.e. preserved when the
	// corresponding instance is terminated) or not.
	Persistent bool `json:"persistent,omitempty"`

	// The amount of computational resources associated with the environment.
	Resources EnvironmentResources `json:"resources"`

	// The mode associated with the environment (Standard, Exam, Exercise)
	Mode EnvironmentMode `json:"mode,omitempty"`

	// +kubebuilder:default=false
	// Whether the environment needs the URL Rewrite or not.
	RewriteURL bool `json:"rewriteURL,omitempty"`

	// Options to customize container startup
	ContainerStartupOptions *ContainerStartupOpts `json:"containerStartupOptions,omitempty"`

	// Name of the storage class to be used for the persistent volume (when needed)
	StorageClassName string `json:"storageClassName,omitempty"`

	// +kubebuilder:default=true
	// Whether the instance has to have the user's MyDrive volume
	MountMyDriveVolume bool `json:"mountMyDriveVolume"`
}

type EnvironmentMode string

type EnvironmentPhase string

type EnvironmentResources struct {

	// The maximum number of CPU cores made available to the environment
	// (at least 1 core). This maps to the 'limits' specified
	// for the actual pod representing the environment.
	CPU uint32 `json:"cpu"`

	// The percentage of reserved CPU cores, ranging between 1 and 100, with
	// respect to the 'CPU' value. Essentially, this corresponds to the 'requests'
	// specified for the actual pod representing the environment.
	ReservedCPUPercentage uint32 `json:"reservedCPUPercentage"`

	// The amount of RAM memory assigned to the given environment. Requests and
	// limits do correspond to avoid OOMKill issues.
	Memory resource.Quantity `json:"memory"`

	// The size of the persistent disk allocated for the given environment.
	// This field is meaningful only in case of persistent or container-based
	// environments, while it is silently ignored in the other cases.
	// In case of containers, when this field is not specified, an emptyDir will be
	// attached to the pod but this could result in data loss whenever the pod dies.
	Disk resource.Quantity `json:"disk,omitempty"`
}

type EnvironmentType string

type GenericRef struct {
	// The name of the resource to be referenced.
	Name string `json:"name"`

	// The namespace containing the resource to be referenced. It should be left
	// empty in case of cluster-wide resources.
	Namespace string `json:"namespace,omitempty"`
}

type Instance struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   InstanceSpec   `json:"spec,omitempty"`
	Status InstanceStatus `json:"status,omitempty"`
}

type InstanceAutomationStatus struct {
	// The last time the Instance desired status was checked.
	LastCheckTime metav1.Time `json:"lastCheckTime,omitempty"`

	// The (possibly expected) termination time of the Instance.
	TerminationTime metav1.Time `json:"terminationTime,omitempty"`

	// The time the Instance content submission has been completed.
	SubmissionTime metav1.Time `json:"submissionTime,omitempty"`
}

type InstanceCustomizationUrls struct {
	// URL from which GET the archive to be extracted into Template.ContainerStartupOptions.ContentPath. This field, if set, OVERRIDES Template.ContainerStartupOptions.SourceArchiveURL.
	ContentOrigin string `json:"contentOrigin,omitempty"`

	// URL to which POST an archive with the contents found (at instance termination) in Template.ContainerStartupOptions.ContentPath.
	ContentDestination string `json:"contentDestination,omitempty"`

	// URL which is periodically checked (with a GET request) to determine automatic instance shutdown. Should return any 2xx status code if the instance has to keep running, any 4xx otherwise. In case of 2xx response, it should output a JSON with a `deadline` field containing a ISO_8601 compliant date/time string of the expected instance termination time. See instautoctrl.StatusCheckResponse for exact definition.
	StatusCheck string `json:"statusCheck,omitempty"`
}

type InstanceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Instance `json:"items"`
}

type InstanceSnapshot struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   InstanceSnapshotSpec   `json:"spec,omitempty"`
	Status InstanceSnapshotStatus `json:"status,omitempty"`
}

type InstanceSnapshotList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []InstanceSnapshot `json:"items"`
}

type InstanceSnapshotSpec struct {

	// Instance is the reference to the persistent VM instance to be snapshotted.
	// The instance should not be running, otherwise it won't be possible to
	// steal the volume and extract its content.
	Instance GenericRef `json:"instanceRef"`

	// Environment represents the reference to the environment to be snapshotted, in case more are
	// associated with the same Instance. If not specified, the first available environment is considered.
	Environment GenericRef `json:"environmentRef,omitempty"`

	// ImageName is the name of the image to pushed in the docker registry.
	ImageName string `json:"imageName"`
}

type InstanceSnapshotStatus struct {
	// Phase represents the current state of the Instance Snapshot.
	Phase SnapshotStatus `json:"phase"`
}

type InstanceSpec struct {
	// The reference to the Template to be instantiated.
	Template GenericRef `json:"template.crownlabs.polito.it/TemplateRef"`

	// The reference to the Tenant which owns the Instance object.
	Tenant GenericRef `json:"tenant.crownlabs.polito.it/TenantRef"`

	// Whether the current instance is running or not.
	// The meaning of this flag is different depending on whether the instance
	// refers to a persistent environment or not. If the first case, it allows to
	// stop the environment (e.g. the underlying VM) without deleting the associated
	// disk. Setting the flag to true will restart the environment, attaching it
	// to the same disk used previously. Differently, if the environment is not
	// persistent, it only tears down the exposition objects, making the instance
	// effectively unreachable from outside the cluster, but allowing the
	// subsequent recreation without data loss.
	Running bool `json:"running"`

	// Custom name the user can assign and change at any time
	// in order to more easily identify the instance.
	// +kubebuilder:validation:Optional
	PrettyName string `json:"prettyName"`

	// Optional urls for advanced integration features.
	CustomizationUrls *InstanceCustomizationUrls `json:"customizationUrls,omitempty"`
}

type InstanceStatus struct {
	// The current status Instance, with reference to the associated environment
	// (e.g. VM). This conveys which resource is being created, as well as
	// whether the associated VM is being scheduled, is running or ready to
	// accept incoming connections.
	Phase EnvironmentPhase `json:"phase,omitempty"`

	// The URL where it is possible to access the remote desktop of the instance
	// (in case of graphical environments)
	URL string `json:"url,omitempty"`

	// The internal IP address associated with the remote environment, which can
	// be used to access it through the SSH protocol (leveraging the SSH bastion
	// in case it is not contacted from another CrownLabs Instance).
	IP string `json:"ip,omitempty"`

	// The amount of time the Instance required to become ready for the first time
	// upon creation.
	InitialReadyTime string `json:"initialReadyTime,omitempty"`

	// Timestamps of the Instance automation phases (check, termination and submission).
	Automation InstanceAutomationStatus `json:"automation,omitempty"`
}

type NameCreated struct {
	// The name of the considered resource.
	Name string `json:"name,omitempty"`

	// Whether the creation succeeded or not.
	Created bool `json:"created"`
}

type SnapshotStatus string

type SubscriptionStatus string

type Template struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   TemplateSpec   `json:"spec,omitempty"`
	Status TemplateStatus `json:"status,omitempty"`
}

type TemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Template `json:"items"`
}

type TemplateSpec struct {
	// The human-readable name of the Template.
	PrettyName string `json:"prettyName"`

	// A textual description of the Template.
	Description string `json:"description"`

	// The reference to the Workspace this Template belongs to.
	WorkspaceRef GenericRef `json:"workspace.crownlabs.polito.it/WorkspaceRef,omitempty"`

	// The list of environments (i.e. VMs or containers) that compose the Template.
	EnvironmentList []Environment `json:"environmentList"`

	// The maximum lifetime of an Instance referencing the current Template.
	// Once this period is expired, the Instance may be automatically deleted
	// or stopped to save resources. If set to "never", the instance will not be
	// automatically terminated.
	DeleteAfter string `json:"deleteAfter,omitempty"`
}

type TemplateStatus struct {
}

type Tenant struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   TenantSpec   `json:"spec,omitempty"`
	Status TenantStatus `json:"status,omitempty"`
}

type TenantList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Tenant `json:"items"`
}

type TenantResourceQuota struct {
	// The maximum amount of CPU which can be used by this Tenant.
	CPU resource.Quantity `json:"cpu"`

	// The maximum amount of RAM memory which can be used by this Tenant.
	Memory resource.Quantity `json:"memory"`

	// +kubebuilder:validation:Minimum:=0
	// The maximum number of concurrent instances which can be created by this Tenant.
	Instances uint32 `json:"instances"`
}

type TenantSpec struct {
	// The first name of the Tenant.
	FirstName string `json:"firstName"`

	// The last name of the Tenant.
	LastName string `json:"lastName"`

	// The last login timestamp.
	LastLogin metav1.Time `json:"lastLogin,omitempty"`

	// The email associated with the Tenant, which will be used to log-in
	// into the system.
	Email string `json:"email"`

	// The list of the Workspaces the Tenant is subscribed to, along with his/her
	// role in each of them.
	// +listType=map
	// +listMapKey=name
	Workspaces []TenantWorkspaceEntry `json:"workspaces,omitempty"`

	// The list of the SSH public keys associated with the Tenant. These will be
	// used to enable to access the remote environments through the SSH protocol.
	PublicKeys []string `json:"publicKeys,omitempty"`

	// Whether a sandbox namespace should be created to allow the Tenant play
	// with Kubernetes.
	CreateSandbox bool `json:"createSandbox,omitempty"`

	// The amount of resources associated with this Tenant, if defined it overrides the one computed from the workspaces the tenant is enrolled in.
	Quota *TenantResourceQuota `json:"quota,omitempty"`
}

type TenantStatus struct {
	// The namespace containing all CrownLabs related objects of the Tenant.
	// This is the namespace that groups his/her own Instances, together with
	// all the accessory resources (e.g. RBACs, resource quota, network policies,
	// ...) created by the tenant-operator.
	PersonalNamespace NameCreated `json:"personalNamespace"`

	// The namespace that can be freely used by the Tenant to play with Kubernetes.
	// This namespace is created only if the .spec.CreateSandbox flag is true.
	SandboxNamespace NameCreated `json:"sandboxNamespace"`

	// The list of Workspaces that are throwing errors during subscription.
	// This mainly happens if .spec.Workspaces contains references to Workspaces
	// which do not exist.
	FailingWorkspaces []string `json:"failingWorkspaces"`

	// The list of the subscriptions to external services (e.g. Keycloak,
	// ...), indicating for each one whether it succeeded or an error
	// occurred.
	Subscriptions map[string]SubscriptionStatus `json:"subscriptions"`

	// Whether all subscriptions and resource creations succeeded or an error
	// occurred. In case of errors, the other status fields provide additional
	// information about which problem occurred.
	// Will be set to true even when personal workspace is intentionally deleted.
	Ready bool `json:"ready"`

	// The amount of resources associated with this Tenant, either inherited from the Workspaces in which he/she is enrolled, or manually overridden.
	Quota TenantResourceQuota `json:"quota,omitempty"`
}

type TenantWorkspaceEntry struct {
	// The Workspace the Tenant is subscribed to.
	Name string `json:"name"`

	// The role of the Tenant in the context of the Workspace.
	Role WorkspaceUserRole `json:"role"`
}

type WorkspaceUserRole string