utils

var AlsoLogToStdErrContainerArg = "--alsologtostderr=true"

var ControllerPluginCsiAddonsContainerCephFsPort = corev1.ContainerPort{
	ContainerPort: int32(9080),
}

var ControllerPluginCsiAddonsContainerRbdPort = corev1.ContainerPort{
	ContainerPort: int32(9070),
}

var ControllerServerContainerArg = "--controllerserver=true"

var CsiAddonsAddressContainerArg = fmt.Sprintf("--csi-addons-address=%s", csiAddonsEndpoint)

var CsiAddonsEndpointContainerArg = fmt.Sprintf("--csi-addons-endpoint=%s", csiAddonsEndpoint)

var CsiAddonsNodeIdContainerArg = fmt.Sprintf("--node-id=$(%s)", NodeIdEnvVar.Name)

var CsiAddonsVolumeConditionArg = "--enable-volume-condition=true"

var CsiAddressContainerArg = fmt.Sprintf("--csi-address=%s", csiEndpoint)

var CsiConfigVolume = corev1.Volume{
	Name: "ceph-csi-config",
	VolumeSource: corev1.VolumeSource{
		ConfigMap: &corev1.ConfigMapVolumeSource{
			LocalObjectReference: corev1.LocalObjectReference{
				Name: "ceph-csi-config",
			},
		},
	},
}

var CsiConfigVolumeMount = corev1.VolumeMount{
	Name:      CsiConfigVolume.Name,
	MountPath: "/etc/ceph-csi-config",
}

var CsiMountInfoVolumeMount = corev1.VolumeMount{
	Name:      csiMountInfoVolumeName,
	MountPath: "/csi/mountinfo",
}

var DefaultFsTypeContainerArg = "--default-fstype=ext4"

var DriverNamespaceContainerArg = fmt.Sprintf("--drivernamespace=$(%s)", DriverNamespaceEnvVar.Name)

var DriverNamespaceEnvVar = corev1.EnvVar{
	Name: "DRIVER_NAMESPACE",
	ValueFrom: &corev1.EnvVarSource{
		FieldRef: &corev1.ObjectFieldSelector{
			FieldPath: "metadata.namespace",
		},
	},
}

var EnableVolumeGroupSnapshotsContainerArg = "--feature-gates=CSIVolumeGroupSnapshot=true"

var EndpointContainerArg = fmt.Sprintf("--endpoint=%s", csiEndpoint)

var EtcSelinuxVolume = corev1.Volume{
	Name: "etc-selinux",
	VolumeSource: corev1.VolumeSource{
		HostPath: &corev1.HostPathVolumeSource{
			Path: "/etc/selinux",
		},
	},
}

var EtcSelinuxVolumeMount = corev1.VolumeMount{
	Name:      EtcSelinuxVolume.Name,
	MountPath: "/etc/selinux",
	ReadOnly:  true,
}

var ExtraCreateMetadataContainerArg = "--extra-create-metadata=true"

var ForceCephKernelClientContainerArg = "--forcecephkernelclient=true"

var HandleVolumeInuseErrorContainerArg = "--handle-volume-inuse-error=false"

var HonorPVReclaimPolicyContainerArg = "--feature-gates=HonorPVReclaimPolicy=true"

var HostDevVolume = corev1.Volume{
	Name: "host-dev",
	VolumeSource: corev1.VolumeSource{
		HostPath: &corev1.HostPathVolumeSource{
			Path: "/dev",
		},
	},
}

var HostDevVolumeMount = corev1.VolumeMount{
	Name:      HostDevVolume.Name,
	MountPath: "/dev",
}

var HostRunMountVolume = corev1.Volume{
	Name: "host-run-mount",
	VolumeSource: corev1.VolumeSource{
		HostPath: &corev1.HostPathVolumeSource{
			Path: "/run/mount",
		},
	},
}

var HostRunMountVolumeMount = corev1.VolumeMount{
	Name:      HostRunMountVolume.Name,
	MountPath: "/run/mount",
}

var HostSysVolume = corev1.Volume{
	Name: "host-sys",
	VolumeSource: corev1.VolumeSource{
		HostPath: &corev1.HostPathVolumeSource{
			Path: "/sys",
		},
	},
}

var HostSysVolumeMount = corev1.VolumeMount{
	Name:      HostSysVolume.Name,
	MountPath: "/sys",
}

var KeysTmpDirVolume = corev1.Volume{
	Name: "keys-tmp-dir",
	VolumeSource: corev1.VolumeSource{
		EmptyDir: &corev1.EmptyDirVolumeSource{
			Medium: corev1.StorageMediumMemory,
		},
	},
}

var KeysTmpDirVolumeMount = corev1.VolumeMount{
	Name:      KeysTmpDirVolume.Name,
	MountPath: "/tmp/csi/keys",
}

var KmsConfigVolumeMount = corev1.VolumeMount{
	Name:      kmsConfigVolumeName,
	MountPath: "/etc/ceph-csi-encryption-kms-config/",
	ReadOnly:  true,
}

var LeaderElectionContainerArg = "--leader-election=true"

var LibModulesVolume = corev1.Volume{
	Name: "lib-modules",
	VolumeSource: corev1.VolumeSource{
		HostPath: &corev1.HostPathVolumeSource{
			Path: "/lib/modules",
		},
	},
}

var LibModulesVolumeMount = corev1.VolumeMount{
	Name:      LibModulesVolume.Name,
	MountPath: "/lib/modules",
	ReadOnly:  true,
}

var LogRotateDirVolumeMount = corev1.VolumeMount{
	Name:      logRotateDirVolumeName,
	MountPath: "/logrotate-config",
}

var LogToStdErrContainerArg = "--logtostderr=false"

var LogsDirVolumeMount = corev1.VolumeMount{
	Name:      logsDirVolumeName,
	MountPath: "/csi-logs",
}

var MetricsPathContainerArg = "--metricspath=/metrics"

var NamespaceContainerArg = fmt.Sprintf("--namespace=$(%s)", PodNamespaceEnvVar.Name)

var NodeIdContainerArg = fmt.Sprintf("--nodeid=$(%s)", NodeIdEnvVar.Name)

var NodeIdEnvVar = corev1.EnvVar{
	Name: "NODE_ID",
	ValueFrom: &corev1.EnvVarSource{
		FieldRef: &corev1.ObjectFieldSelector{
			FieldPath: "spec.nodeName",
		},
	},
}

var NodePluginCsiAddonsContainerPort = corev1.ContainerPort{
	ContainerPort: int32(9071),
}

var NodeServerContainerArg = "--nodeserver=true"

var OidcTokenVolume = corev1.Volume{
	Name: "oidc-token",
	VolumeSource: corev1.VolumeSource{
		Projected: &corev1.ProjectedVolumeSource{
			Sources: []corev1.VolumeProjection{
				{
					ServiceAccountToken: &corev1.ServiceAccountTokenProjection{
						Path:              "oidc-token",
						ExpirationSeconds: ptr.To(int64(3600)),
						Audience:          "ceph-csi-kms",
					},
				},
			},
		},
	},
}

var OidcTokenVolumeMount = corev1.VolumeMount{
	Name:      OidcTokenVolume.Name,
	MountPath: "/run/secrets/tokens",
	ReadOnly:  true,
}

var PidlimitContainerArg = "--pidlimit=-1"

var PluginDirVolumeMount = corev1.VolumeMount{
	Name:      pluginDirVolumeName,
	MountPath: "/csi",
}

var PodContainerArg = fmt.Sprintf("--pod=$(%s)", PodNameEnvVar.Name)

var PodIpEnvVar = corev1.EnvVar{
	Name: "POD_IP",
	ValueFrom: &corev1.EnvVarSource{
		FieldRef: &corev1.ObjectFieldSelector{
			FieldPath: "status.podIP",
		},
	},
}

var PodNameEnvVar = corev1.EnvVar{
	Name: "POD_NAME",
	ValueFrom: &corev1.EnvVarSource{
		FieldRef: &corev1.ObjectFieldSelector{
			FieldPath: "metadata.name",
		},
	},
}

var PodNamespaceEnvVar = corev1.EnvVar{
	Name: "POD_NAMESPACE",
	ValueFrom: &corev1.EnvVarSource{
		FieldRef: &corev1.ObjectFieldSelector{
			FieldPath: "metadata.namespace",
		},
	},
}

var PodUidContainerArg = fmt.Sprintf("--pod-uid=$(%s)", PodUidEnvVar.Name)

var PodUidEnvVar = corev1.EnvVar{
	Name: "POD_UID",
	ValueFrom: &corev1.EnvVarSource{
		FieldRef: &corev1.ObjectFieldSelector{
			FieldPath: "metadata.uid",
		},
	},
}

var PoolTimeContainerArg = "--polltime=60s"

var PreventVolumeModeConversionContainerArg = "--prevent-volume-mode-conversion=true"

var RecoverVolumeExpansionFailureContainerArg = "--feature-gates=RecoverVolumeExpansionFailure=true"

var RegistrationDirVolumeMount = corev1.VolumeMount{
	Name:      registrationVolumeName,
	MountPath: "/registration",
}

var RetryIntervalStartContainerArg = "--retry-interval-start=500ms"

var SnapshotMetadataGrpcPort = corev1.ContainerPort{
	ContainerPort: int32(50051),
}

var SnapshotMetadataGrpcServicePortArg = fmt.Sprintf("--port=%d", SnapshotMetadataGrpcPort.ContainerPort)

var SnapshotMetadataTlsCertArg = "--tls-cert=/tmp/certificates/tls.crt"

var SnapshotMetadataTlsKeyArg = "--tls-key=/tmp/certificates/tls.key"

var SocketDirVolume = corev1.Volume{
	Name: "socket-dir",
	VolumeSource: corev1.VolumeSource{
		EmptyDir: &corev1.EmptyDirVolumeSource{
			Medium: corev1.StorageMediumMemory,
		},
	},
}

var SocketDirVolumeMount = corev1.VolumeMount{
	Name:      SocketDirVolume.Name,
	MountPath: SocketDir,
}