// Code generated for package generated by go-bindata DO NOT EDIT. (@generated)
// sources:
// assets/csidriveroperators/aws-ebs/01_namespace.yaml
// assets/csidriveroperators/aws-ebs/02_sa.yaml
// assets/csidriveroperators/aws-ebs/03_role.yaml
// assets/csidriveroperators/aws-ebs/04_rolebinding.yaml
// assets/csidriveroperators/aws-ebs/05_clusterrole.yaml
// assets/csidriveroperators/aws-ebs/06_clusterrolebinding.yaml
// assets/csidriveroperators/aws-ebs/07_deployment.yaml
// assets/csidriveroperators/aws-ebs/08_cr.yaml
// assets/csidriveroperators/manila/01_namespace.yaml
// assets/csidriveroperators/manila/02_sa.yaml
// assets/csidriveroperators/manila/03_role.yaml
// assets/csidriveroperators/manila/04_rolebinding.yaml
// assets/csidriveroperators/manila/05_clusterrole.yaml
// assets/csidriveroperators/manila/06_clusterrolebinding.yaml
// assets/csidriveroperators/manila/07_deployment.yaml
// assets/csidriveroperators/manila/08_cr.yaml
// assets/csidriveroperators/ovirt/01_namespace.yaml
// assets/csidriveroperators/ovirt/02_sa.yaml
// assets/csidriveroperators/ovirt/03_role.yaml
// assets/csidriveroperators/ovirt/04_rolebinding.yaml
// assets/csidriveroperators/ovirt/05_clusterrole.yaml
// assets/csidriveroperators/ovirt/06_clusterrolebinding.yaml
// assets/csidriveroperators/ovirt/07_deployment.yaml
// assets/csidriveroperators/ovirt/08_cr.yaml
// assets/storageclasses/aws.yaml
// assets/storageclasses/azure.yaml
// assets/storageclasses/gcp.yaml
// assets/storageclasses/openstack.yaml
// assets/storageclasses/vsphere.yaml
package generated

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

// Name return file name
func (fi bindataFileInfo) Name() string {
	return fi.name
}

// Size return file size
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}

// Mode return file mode
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}

// Mode return file modify time
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}

// IsDir return file whether a directory
func (fi bindataFileInfo) IsDir() bool {
	return fi.mode&os.ModeDir != 0
}

// Sys return file is sys mode
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _csidriveroperatorsAwsEbs01_namespaceYaml = []byte(`apiVersion: v1
kind: Namespace
metadata:
  name: openshift-cluster-csi-drivers
  annotations:
    openshift.io/node-selector: ""
`)

func csidriveroperatorsAwsEbs01_namespaceYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs01_namespaceYaml, nil
}

func csidriveroperatorsAwsEbs01_namespaceYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs01_namespaceYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/01_namespace.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs02_saYaml = []byte(`apiVersion: v1
kind: ServiceAccount
metadata:
  name: aws-ebs-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsAwsEbs02_saYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs02_saYaml, nil
}

func csidriveroperatorsAwsEbs02_saYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs02_saYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/02_sa.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs03_roleYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: aws-ebs-csi-driver-operator-role
  namespace: openshift-cluster-csi-drivers
rules:
- apiGroups:
  - ''
  resources:
  - pods
  - services
  - endpoints
  - persistentvolumeclaims
  - events
  - configmaps
  - secrets
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - namespaces
  verbs:
  - get
- apiGroups:
  - apps
  resources:
  - deployments
  - daemonsets
  - replicasets
  - statefulsets
  verbs:
  - '*'
- apiGroups:
  - monitoring.coreos.com
  resources:
  - servicemonitors
  verbs:
  - get
  - create
`)

func csidriveroperatorsAwsEbs03_roleYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs03_roleYaml, nil
}

func csidriveroperatorsAwsEbs03_roleYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs03_roleYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/03_role.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs04_rolebindingYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: aws-ebs-csi-driver-operator-rolebinding
  namespace: openshift-cluster-csi-drivers
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: aws-ebs-csi-driver-operator-role
subjects:
- kind: ServiceAccount
  name: aws-ebs-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsAwsEbs04_rolebindingYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs04_rolebindingYaml, nil
}

func csidriveroperatorsAwsEbs04_rolebindingYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs04_rolebindingYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/04_rolebinding.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs05_clusterroleYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: aws-ebs-csi-driver-operator-clusterrole
rules:
- apiGroups:
  - security.openshift.io
  resourceNames:
  - privileged
  resources:
  - securitycontextconstraints
  verbs:
  - use
- apiGroups:
  - operator.openshift.io
  resources:
  - clustercsidrivers
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - operator.openshift.io
  resources:
  - clustercsidrivers/status
  verbs:
  - get
  - list
  - watch
  - update
  - patch
- apiGroups:
  - ''
  resourceNames:
  - extension-apiserver-authentication
  - aws-ebs-csi-driver-operator-lock
  resources:
  - configmaps
  verbs:
  - '*'
- apiGroups:
  - rbac.authorization.k8s.io
  resources:
  - clusterroles
  - clusterrolebindings
  - roles
  - rolebindings
  verbs:
  - watch
  - list
  - get
  - create
  - delete
  - patch
  - update
- apiGroups:
  - ''
  resources:
  - serviceaccounts
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
  - delete
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - list
  - create
  - watch
  - delete
- apiGroups:
  - coordination.k8s.io
  resources:
  - leases
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - nodes
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - secrets
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - ''
  resources:
  - namespaces
  verbs:
  - get
  - list
  - watch
  - create
  - patch
  - delete
  - update
- apiGroups:
  - ''
  resources:
  - persistentvolumes
  verbs:
  - create
  - delete
  - list
  - get
  - watch
  - update
  - patch
- apiGroups:
  - ''
  resources:
  - persistentvolumeclaims
  verbs:
  - get
  - list
  - watch
  - update
- apiGroups:
  - ''
  resources:
  - pods
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - ''
  resources:
  - persistentvolumeclaims/status
  verbs:
  - patch
  - update
- apiGroups:
  - apps
  resources:
  - deployments
  - daemonsets
  - replicasets
  - statefulsets
  verbs:
  - '*'
- apiGroups:
  - storage.k8s.io
  resources:
  - volumeattachments
  verbs:
  - get
  - list
  - watch
  - update
  - delete
  - create
  - patch
- apiGroups:
  - storage.k8s.io
  resources:
  - volumeattachments/status
  verbs:
  - patch
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotcontents/status
  verbs:
  - update
  - patch
- apiGroups:
  - storage.k8s.io
  resources:
  - storageclasses
  - csinodes
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - '*'
  resources:
  - events
  verbs:
  - get
  - patch
  - create
  - list
  - watch
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotclasses
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotcontents
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshots
  verbs:
  - get
  - list
  - watch
  - update
- apiGroups:
  - storage.k8s.io
  resources:
  - csidrivers
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - cloudcredential.openshift.io
  resources:
  - credentialsrequests
  verbs:
  - '*'
- apiGroups:
  - config.openshift.io
  resources:
  - infrastructures
  verbs:
  - get
  - list
  - watch
`)

func csidriveroperatorsAwsEbs05_clusterroleYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs05_clusterroleYaml, nil
}

func csidriveroperatorsAwsEbs05_clusterroleYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs05_clusterroleYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/05_clusterrole.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs06_clusterrolebindingYaml = []byte(`kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: aws-ebs-csi-driver-operator-clusterrolebinding
subjects:
  - kind: ServiceAccount
    name: aws-ebs-csi-driver-operator
    namespace: openshift-cluster-csi-drivers
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: aws-ebs-csi-driver-operator-clusterrole
`)

func csidriveroperatorsAwsEbs06_clusterrolebindingYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs06_clusterrolebindingYaml, nil
}

func csidriveroperatorsAwsEbs06_clusterrolebindingYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs06_clusterrolebindingYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/06_clusterrolebinding.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs07_deploymentYaml = []byte(`apiVersion: apps/v1
kind: Deployment
metadata:
  name: aws-ebs-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
spec:
  replicas: 1
  selector:
    matchLabels:
      name: aws-ebs-csi-driver-operator
  strategy: {}
  template:
    metadata:
      labels:
        name: aws-ebs-csi-driver-operator
    spec:
      containers:
      - args:
        - start
        - -v=${LOG_LEVEL}
        env:
        - name: DRIVER_IMAGE
          value: ${DRIVER_IMAGE}
        - name: PROVISIONER_IMAGE
          value: ${PROVISIONER_IMAGE}
        - name: ATTACHER_IMAGE
          value: ${ATTACHER_IMAGE}
        - name: RESIZER_IMAGE
          value: ${RESIZER_IMAGE}
        - name: SNAPSHOTTER_IMAGE
          value: ${SNAPSHOTTER_IMAGE}
        - name: NODE_DRIVER_REGISTRAR_IMAGE
          value: ${NODE_DRIVER_REGISTRAR_IMAGE}
        - name: LIVENESS_PROBE_IMAGE
          value: ${LIVENESS_PROBE_IMAGE}
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        image: ${OPERATOR_IMAGE}
        imagePullPolicy: IfNotPresent
        name: aws-ebs-csi-driver-operator
        resources:
          requests:
            memory: 50Mi
            cpu: 10m
      priorityClassName: system-cluster-critical
      serviceAccountName: aws-ebs-csi-driver-operator
      nodeSelector:
        node-role.kubernetes.io/master: ""
      tolerations:
      - key: CriticalAddonsOnly
        operator: Exists
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: "NoSchedule"
`)

func csidriveroperatorsAwsEbs07_deploymentYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs07_deploymentYaml, nil
}

func csidriveroperatorsAwsEbs07_deploymentYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs07_deploymentYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/07_deployment.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsAwsEbs08_crYaml = []byte(`apiVersion: operator.openshift.io/v1
kind: "ClusterCSIDriver"
metadata:
  name: "ebs.csi.aws.com"
spec:
  logLevel: Normal
  managementState: Managed
  operatorLogLevel: Normal
`)

func csidriveroperatorsAwsEbs08_crYamlBytes() ([]byte, error) {
	return _csidriveroperatorsAwsEbs08_crYaml, nil
}

func csidriveroperatorsAwsEbs08_crYaml() (*asset, error) {
	bytes, err := csidriveroperatorsAwsEbs08_crYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/aws-ebs/08_cr.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila01_namespaceYaml = []byte(`apiVersion: v1
kind: Namespace
metadata:
  name: openshift-cluster-csi-drivers
  annotations:
    openshift.io/node-selector: ""
`)

func csidriveroperatorsManila01_namespaceYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila01_namespaceYaml, nil
}

func csidriveroperatorsManila01_namespaceYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila01_namespaceYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/01_namespace.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila02_saYaml = []byte(`apiVersion: v1
kind: ServiceAccount
metadata:
  name: manila-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsManila02_saYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila02_saYaml, nil
}

func csidriveroperatorsManila02_saYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila02_saYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/02_sa.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila03_roleYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: manila-csi-driver-operator-role
  namespace: openshift-cluster-csi-drivers
rules:
- apiGroups:
  - ''
  resources:
  - pods
  - services
  - endpoints
  - persistentvolumeclaims
  - events
  - configmaps
  - secrets
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - namespaces
  verbs:
  - get
- apiGroups:
  - apps
  resources:
  - deployments
  - daemonsets
  - replicasets
  - statefulsets
  verbs:
  - '*'
- apiGroups:
  - monitoring.coreos.com
  resources:
  - servicemonitors
  verbs:
  - get
  - create
`)

func csidriveroperatorsManila03_roleYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila03_roleYaml, nil
}

func csidriveroperatorsManila03_roleYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila03_roleYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/03_role.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila04_rolebindingYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: manila-csi-driver-operator-rolebinding
  namespace: openshift-cluster-csi-drivers
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: manila-csi-driver-operator-role
subjects:
- kind: ServiceAccount
  name: manila-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsManila04_rolebindingYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila04_rolebindingYaml, nil
}

func csidriveroperatorsManila04_rolebindingYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila04_rolebindingYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/04_rolebinding.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila05_clusterroleYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: manila-csi-driver-operator-clusterrole
rules:
- apiGroups:
  - security.openshift.io
  resourceNames:
  - privileged
  resources:
  - securitycontextconstraints
  verbs:
  - use

# The operator needs these config maps:
# - read/write openshift-manila-csi-driver/cloud-provider-config
# - read-only kube-system/extension-apiserver-authentication
# - read/write manila-csi-driver-operator-lock
- apiGroups:
  - ''
  resources:
  - configmaps
  verbs:
  - watch
  - list
  - get
  - create
  - delete
  - patch
  - update
- apiGroups:
  - rbac.authorization.k8s.io
  resources:
  - clusterroles
  - clusterrolebindings
  - roles
  - rolebindings
  verbs:
  - watch
  - list
  - get
  - create
  - delete
  - patch
  - update
- apiGroups:
  - ''
  resources:
  - serviceaccounts
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
  - delete
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - list
  - create
  - watch
  - delete
- apiGroups:
  - coordination.k8s.io
  resources:
  - leases
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - nodes
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - secrets
  verbs:
  - get
  - list
  - watch
  # For CA certificate sync
  - create
  - patch
  - update
- apiGroups:
  - ''
  resources:
  - namespaces
  verbs:
  - get
  - list
  - watch
  - create
  - patch
  - delete
  - update
- apiGroups:
  - ''
  resources:
  - persistentvolumes
  verbs:
  - create
  - delete
  - list
  - get
  - watch
  - update
  - patch
- apiGroups:
  - ''
  resources:
  - persistentvolumeclaims
  verbs:
  - get
  - list
  - watch
  - update
- apiGroups:
  - ''
  resources:
  - persistentvolumeclaims/status
  verbs:
  - patch
  - update
- apiGroups:
  - apps
  resources:
  - deployments
  - daemonsets
  - replicasets
  - statefulsets
  verbs:
  - '*'
- apiGroups:
  - storage.k8s.io
  resources:
  - volumeattachments
  verbs:
  - get
  - list
  - watch
  - update
  - delete
  - create
  - patch
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotcontents/status
  verbs:
  - update
  - patch
- apiGroups:
  - storage.k8s.io
  resources:
  - storageclasses
  - csinodes
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - '*'
  resources:
  - events
  verbs:
  - get
  - patch
  - create
  - list
  - watch
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotclasses
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotcontents
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshots
  verbs:
  - get
  - list
  - watch
  - update
- apiGroups:
  - storage.k8s.io
  resources:
  - csidrivers
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - csi.openshift.io
  resources:
  - '*'
  verbs:
  - '*'
- apiGroups:
  - cloudcredential.openshift.io
  resources:
  - credentialsrequests
  verbs:
  - '*'
- apiGroups:
  - config.openshift.io
  resources:
  - infrastructures
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - operator.openshift.io
  resources:
  - 'clustercsidrivers'
  - 'clustercsidrivers/status'
  verbs:
  - '*'
`)

func csidriveroperatorsManila05_clusterroleYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila05_clusterroleYaml, nil
}

func csidriveroperatorsManila05_clusterroleYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila05_clusterroleYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/05_clusterrole.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila06_clusterrolebindingYaml = []byte(`apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: manila-csi-driver-operator-clusterrolebinding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: manila-csi-driver-operator-clusterrole
subjects:
- kind: ServiceAccount
  name: manila-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsManila06_clusterrolebindingYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila06_clusterrolebindingYaml, nil
}

func csidriveroperatorsManila06_clusterrolebindingYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila06_clusterrolebindingYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/06_clusterrolebinding.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila07_deploymentYaml = []byte(`apiVersion: apps/v1
kind: Deployment
metadata:
  name: manila-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
spec:
  replicas: 1
  selector:
    matchLabels:
      name: manila-csi-driver-operator
  strategy: {}
  template:
    metadata:
      labels:
        name: manila-csi-driver-operator
    spec:
      containers:
      - args:
        - start
        - -v=${LOG_LEVEL}
        env:
        - name: DRIVER_IMAGE
          value: ${DRIVER_IMAGE}
        - name: NFS_DRIVER_IMAGE
          value: ${NFS_DRIVER_IMAGE}
        - name: PROVISIONER_IMAGE
          value: ${PROVISIONER_IMAGE}
        - name: ATTACHER_IMAGE
          value: ${ATTACHER_IMAGE}
        - name: RESIZER_IMAGE
          value: ${RESIZER_IMAGE}
        - name: SNAPSHOTTER_IMAGE
          value: ${SNAPSHOTTER_IMAGE}
        - name: NODE_DRIVER_REGISTRAR_IMAGE
          value: ${NODE_DRIVER_REGISTRAR_IMAGE}
        - name: LIVENESS_PROBE_IMAGE
          value: ${LIVENESS_PROBE_IMAGE}
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        image: ${OPERATOR_IMAGE}
        imagePullPolicy: IfNotPresent
        name: manila-csi-driver-operator
        volumeMounts:
        - name: cacert
          mountPath: /etc/openstack-ca/
        - name: cloud-credentials
          # Create /etc/openstack/clouds.yaml
          mountPath: /etc/openstack/
        resources:
          requests:
            memory: 50Mi
            cpu: 10m
      priorityClassName: system-cluster-critical
      serviceAccountName: manila-csi-driver-operator
      nodeSelector:
        node-role.kubernetes.io/master: ""
      tolerations:
      - key: CriticalAddonsOnly
        operator: Exists
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: "NoSchedule"
      volumes:
      - name: cacert
        # Extract ca-bundle.pem to /usr/share/pki/ca-trust-source if present.
        # Let the pod start when the ConfigMap does not exist or the certificate
        # is not preset there. The certificate file will be created once the
        # ConfigMap is created / the cerificate is added to it.
        configMap:
          name: cloud-provider-config
          items:
            - key: ca-bundle.pem
              path: ca-bundle.pem
          optional: true
      - name: cloud-credentials
        secret:
          secretName: manila-cloud-credentials
          optional: false
`)

func csidriveroperatorsManila07_deploymentYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila07_deploymentYaml, nil
}

func csidriveroperatorsManila07_deploymentYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila07_deploymentYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/07_deployment.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsManila08_crYaml = []byte(`apiVersion: operator.openshift.io/v1
kind: ClusterCSIDriver
metadata:
  name: manila.csi.openstack.org
spec:
  managementState: Managed
  logLevel: Normal
  operatorLogLevel: Normal
`)

func csidriveroperatorsManila08_crYamlBytes() ([]byte, error) {
	return _csidriveroperatorsManila08_crYaml, nil
}

func csidriveroperatorsManila08_crYaml() (*asset, error) {
	bytes, err := csidriveroperatorsManila08_crYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/manila/08_cr.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt01_namespaceYaml = []byte(`apiVersion: v1
kind: Namespace
metadata:
  name: openshift-cluster-csi-drivers
  annotations:
    openshift.io/node-selector: ""
`)

func csidriveroperatorsOvirt01_namespaceYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt01_namespaceYaml, nil
}

func csidriveroperatorsOvirt01_namespaceYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt01_namespaceYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/01_namespace.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt02_saYaml = []byte(`---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: ovirt-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsOvirt02_saYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt02_saYaml, nil
}

func csidriveroperatorsOvirt02_saYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt02_saYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/02_sa.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt03_roleYaml = []byte(`---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: ovirt-csi-driver-operator-role
  namespace: openshift-cluster-csi-drivers
rules:
  - apiGroups:
      - ''
    resources:
      - pods
      - services
      - endpoints
      - persistentvolumeclaims
      - events
      - configmaps
      - secrets
    verbs:
      - '*'
  - apiGroups:
      - ''
    resources:
      - namespaces
    verbs:
      - get
  - apiGroups:
      - apps
    resources:
      - deployments
      - daemonsets
      - replicasets
      - statefulsets
    verbs:
      - '*'
  - apiGroups:
      - monitoring.coreos.com
    resources:
      - servicemonitors
    verbs:
      - get
      - create
`)

func csidriveroperatorsOvirt03_roleYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt03_roleYaml, nil
}

func csidriveroperatorsOvirt03_roleYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt03_roleYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/03_role.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt04_rolebindingYaml = []byte(`---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: ovirt-csi-driver-operator-rolebinding
  namespace: openshift-cluster-csi-drivers
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: ovirt-csi-driver-operator-role
subjects:
  - kind: ServiceAccount
    name: ovirt-csi-driver-operator
    namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsOvirt04_rolebindingYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt04_rolebindingYaml, nil
}

func csidriveroperatorsOvirt04_rolebindingYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt04_rolebindingYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/04_rolebinding.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt05_clusterroleYaml = []byte(`---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: ovirt-csi-driver-operator-clusterrole
rules:
- apiGroups:
  - security.openshift.io
  resourceNames:
  - privileged
  resources:
  - securitycontextconstraints
  verbs:
  - use
- apiGroups:
  - ''
  resourceNames:
  - extension-apiserver-authentication
  - ovirt-csi-driver-operator-lock
  resources:
  - configmaps
  verbs:
  - '*'
- apiGroups:
  - rbac.authorization.k8s.io
  resources:
  - clusterroles
  - clusterrolebindings
  - roles
  - rolebindings
  verbs:
  - watch
  - list
  - get
  - create
  - delete
  - patch
  - update
- apiGroups:
  - ''
  resources:
  - serviceaccounts
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
  - delete
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - list
  - create
  - watch
  - delete
- apiGroups:
  - coordination.k8s.io
  resources:
  - leases
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - nodes
  verbs:
  - '*'
- apiGroups:
  - ''
  resources:
  - secrets
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - ''
  resources:
  - namespaces
  verbs:
  - get
  - list
  - watch
  - create
  - patch
  - delete
  - update
- apiGroups:
  - ''
  resources:
  - persistentvolumes
  verbs:
  - create
  - delete
  - list
  - get
  - watch
  - update
  - patch
- apiGroups:
  - ''
  resources:
  - persistentvolumeclaims
  verbs:
  - get
  - list
  - watch
  - update
- apiGroups:
  - ''
  resources:
  - persistentvolumeclaims/status
  verbs:
  - patch
  - update
- apiGroups:
  - apps
  resources:
  - deployments
  - daemonsets
  - replicasets
  - statefulsets
  verbs:
  - '*'
- apiGroups:
  - storage.k8s.io
  resources:
  - volumeattachments
  verbs:
  - get
  - list
  - watch
  - update
  - delete
  - create
  - patch
- apiGroups:
  - storage.k8s.io
  resources:
  - volumeattachments/status
  verbs:
  - patch
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotcontents/status
  verbs:
  - update
  - patch
- apiGroups:
  - storage.k8s.io
  resources:
  - storageclasses
  - csinodes
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - '*'
  resources:
  - events
  verbs:
  - get
  - patch
  - create
  - list
  - watch
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotclasses
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshotcontents
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - snapshot.storage.k8s.io
  resources:
  - volumesnapshots
  verbs:
  - get
  - list
  - watch
  - update
- apiGroups:
  - storage.k8s.io
  resources:
  - csidrivers
  verbs:
  - create
  - get
  - list
  - watch
  - update
  - delete
- apiGroups:
  - csi.openshift.io
  resources:
  - '*'
  verbs:
  - '*'
- apiGroups:
  - cloudcredential.openshift.io
  resources:
  - credentialsrequests
  verbs:
  - '*'
- apiGroups:
  - config.openshift.io
  resources:
  - infrastructures
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - operator.openshift.io
  resources:
  - clustercsidrivers
  - clustercsidrivers/status
  verbs:
  - get
  - list
  - watch
  - update
`)

func csidriveroperatorsOvirt05_clusterroleYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt05_clusterroleYaml, nil
}

func csidriveroperatorsOvirt05_clusterroleYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt05_clusterroleYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/05_clusterrole.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt06_clusterrolebindingYaml = []byte(`---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ovirt-csi-driver-operator-clusterrolebinding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: ovirt-csi-driver-operator-clusterrole
subjects:
- kind: ServiceAccount
  name: ovirt-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
`)

func csidriveroperatorsOvirt06_clusterrolebindingYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt06_clusterrolebindingYaml, nil
}

func csidriveroperatorsOvirt06_clusterrolebindingYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt06_clusterrolebindingYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/06_clusterrolebinding.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt07_deploymentYaml = []byte(`---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ovirt-csi-driver-operator
  namespace: openshift-cluster-csi-drivers
spec:
  replicas: 1
  selector:
    matchLabels:
      name: ovirt-csi-driver-operator
  template:
    metadata:
      labels:
        name: ovirt-csi-driver-operator
    spec:
      serviceAccountName: ovirt-csi-driver-operator
      priorityClassName: system-cluster-critical
      nodeSelector:
        node-role.kubernetes.io/master: ""
      tolerations:
      - key: CriticalAddonsOnly
        operator: Exists
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: "NoSchedule"
      initContainers:
        - name: prepare-ovirt-config
          env:
            - name: OVIRT_URL
              valueFrom:
                secretKeyRef:
                  name: ovirt-credentials
                  key: ovirt_url
            - name: OVIRT_USERNAME
              valueFrom:
                secretKeyRef:
                  name: ovirt-credentials
                  key: ovirt_username
            - name: OVIRT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: ovirt-credentials
                  key: ovirt_password
            - name: OVIRT_CAFILE
              value: /tmp/config/ovirt-engine-ca.pem
            - name: OVIRT_INSECURE
              valueFrom:
                secretKeyRef:
                  name: ovirt-credentials
                  key: ovirt_insecure
            - name: OVIRT_CA_BUNDLE
              valueFrom:
                secretKeyRef:
                  name: ovirt-credentials
                  key: ovirt_ca_bundle
          image: ${OPERATOR_IMAGE}
          resources:
            requests:
              memory: 50Mi
              cpu: 10m
          command:
            - /bin/sh
            - -c
            - |
              #!/bin/sh
              cat << EOF > /tmp/config/ovirt-config.yaml
              ovirt_url: $OVIRT_URL
              ovirt_username: $OVIRT_USERNAME
              ovirt_password: $OVIRT_PASSWORD
              # set a valid path only if ca bundle has content
              ovirt_cafile: ${OVIRT_CA_BUNDLE:+$OVIRT_CAFILE}
              ovirt_insecure: $OVIRT_INSECURE
              EOF
              if [[ -n "$OVIRT_CA_BUNDLE" ]]; then echo "$OVIRT_CA_BUNDLE" > $OVIRT_CAFILE ; fi
          volumeMounts:
            - name: config
              mountPath: /tmp/config
      containers:
        - name: ovirt-csi-driver-operator
          image: ${OPERATOR_IMAGE}
          imagePullPolicy: IfNotPresent
          resources:
            requests:
              memory: 50Mi
              cpu: 10m
          args:
            - start
            - "--node=$(KUBE_NODE_NAME)"
            - -v=${LOG_LEVEL}
          env:
            - name: OPERATOR_NAME
              value: ovirt-csi-driver-operator
            - name: DRIVER_IMAGE
              value: ${DRIVER_IMAGE}
            - name: PROVISIONER_IMAGE
              value: ${PROVISIONER_IMAGE}
            - name: ATTACHER_IMAGE
              value: ${ATTACHER_IMAGE}
            - name: RESIZER_IMAGE
              value: ${RESIZER_IMAGE}
            - name: SNAPSHOTTER_IMAGE
              value: ${SNAPSHOTTER_IMAGE}
            - name: NODE_DRIVER_REGISTRAR_IMAGE
              value: ${NODE_DRIVER_REGISTRAR_IMAGE}
            - name: LIVENESS_PROBE_IMAGE
              value: ${LIVENESS_PROBE_IMAGE}
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: KUBE_NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName

            - name: OVIRT_CONFIG
              value: /tmp/config/ovirt-config.yaml
          volumeMounts:
            - name: config
              mountPath: /tmp/config
      volumes:
        - name: config
          emptyDir: {}
`)

func csidriveroperatorsOvirt07_deploymentYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt07_deploymentYaml, nil
}

func csidriveroperatorsOvirt07_deploymentYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt07_deploymentYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/07_deployment.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _csidriveroperatorsOvirt08_crYaml = []byte(`---
apiVersion: operator.openshift.io/v1
kind: ClusterCSIDriver
metadata:
  name: csi.ovirt.org
spec:
  logLevel: Normal
  managementState: Managed
  operatorLogLevel: Normal
`)

func csidriveroperatorsOvirt08_crYamlBytes() ([]byte, error) {
	return _csidriveroperatorsOvirt08_crYaml, nil
}

func csidriveroperatorsOvirt08_crYaml() (*asset, error) {
	bytes, err := csidriveroperatorsOvirt08_crYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "csidriveroperators/ovirt/08_cr.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _storageclassesAwsYaml = []byte(`apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: gp2
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp2
  encrypted: "true"
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
reclaimPolicy: Delete`)

func storageclassesAwsYamlBytes() ([]byte, error) {
	return _storageclassesAwsYaml, nil
}

func storageclassesAwsYaml() (*asset, error) {
	bytes, err := storageclassesAwsYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "storageclasses/aws.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _storageclassesAzureYaml = []byte(`apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: managed-premium
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/azure-disk
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
parameters:
  kind: Managed
  storageaccounttype: Premium_LRS
reclaimPolicy: Delete
`)

func storageclassesAzureYamlBytes() ([]byte, error) {
	return _storageclassesAzureYaml, nil
}

func storageclassesAzureYaml() (*asset, error) {
	bytes, err := storageclassesAzureYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "storageclasses/azure.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _storageclassesGcpYaml = []byte(`apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/gce-pd
parameters:
  type: pd-standard
  replication-type: none
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
reclaimPolicy: Delete
`)

func storageclassesGcpYamlBytes() ([]byte, error) {
	return _storageclassesGcpYaml, nil
}

func storageclassesGcpYaml() (*asset, error) {
	bytes, err := storageclassesGcpYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "storageclasses/gcp.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _storageclassesOpenstackYaml = []byte(`apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/cinder
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
reclaimPolicy: Delete
`)

func storageclassesOpenstackYamlBytes() ([]byte, error) {
	return _storageclassesOpenstackYaml, nil
}

func storageclassesOpenstackYaml() (*asset, error) {
	bytes, err := storageclassesOpenstackYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "storageclasses/openstack.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _storageclassesVsphereYaml = []byte(`apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: thin
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/vsphere-volume
parameters:
  diskformat: thin
reclaimPolicy: Delete
`)

func storageclassesVsphereYamlBytes() ([]byte, error) {
	return _storageclassesVsphereYaml, nil
}

func storageclassesVsphereYaml() (*asset, error) {
	bytes, err := storageclassesVsphereYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "storageclasses/vsphere.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"csidriveroperators/aws-ebs/01_namespace.yaml":          csidriveroperatorsAwsEbs01_namespaceYaml,
	"csidriveroperators/aws-ebs/02_sa.yaml":                 csidriveroperatorsAwsEbs02_saYaml,
	"csidriveroperators/aws-ebs/03_role.yaml":               csidriveroperatorsAwsEbs03_roleYaml,
	"csidriveroperators/aws-ebs/04_rolebinding.yaml":        csidriveroperatorsAwsEbs04_rolebindingYaml,
	"csidriveroperators/aws-ebs/05_clusterrole.yaml":        csidriveroperatorsAwsEbs05_clusterroleYaml,
	"csidriveroperators/aws-ebs/06_clusterrolebinding.yaml": csidriveroperatorsAwsEbs06_clusterrolebindingYaml,
	"csidriveroperators/aws-ebs/07_deployment.yaml":         csidriveroperatorsAwsEbs07_deploymentYaml,
	"csidriveroperators/aws-ebs/08_cr.yaml":                 csidriveroperatorsAwsEbs08_crYaml,
	"csidriveroperators/manila/01_namespace.yaml":           csidriveroperatorsManila01_namespaceYaml,
	"csidriveroperators/manila/02_sa.yaml":                  csidriveroperatorsManila02_saYaml,
	"csidriveroperators/manila/03_role.yaml":                csidriveroperatorsManila03_roleYaml,
	"csidriveroperators/manila/04_rolebinding.yaml":         csidriveroperatorsManila04_rolebindingYaml,
	"csidriveroperators/manila/05_clusterrole.yaml":         csidriveroperatorsManila05_clusterroleYaml,
	"csidriveroperators/manila/06_clusterrolebinding.yaml":  csidriveroperatorsManila06_clusterrolebindingYaml,
	"csidriveroperators/manila/07_deployment.yaml":          csidriveroperatorsManila07_deploymentYaml,
	"csidriveroperators/manila/08_cr.yaml":                  csidriveroperatorsManila08_crYaml,
	"csidriveroperators/ovirt/01_namespace.yaml":            csidriveroperatorsOvirt01_namespaceYaml,
	"csidriveroperators/ovirt/02_sa.yaml":                   csidriveroperatorsOvirt02_saYaml,
	"csidriveroperators/ovirt/03_role.yaml":                 csidriveroperatorsOvirt03_roleYaml,
	"csidriveroperators/ovirt/04_rolebinding.yaml":          csidriveroperatorsOvirt04_rolebindingYaml,
	"csidriveroperators/ovirt/05_clusterrole.yaml":          csidriveroperatorsOvirt05_clusterroleYaml,
	"csidriveroperators/ovirt/06_clusterrolebinding.yaml":   csidriveroperatorsOvirt06_clusterrolebindingYaml,
	"csidriveroperators/ovirt/07_deployment.yaml":           csidriveroperatorsOvirt07_deploymentYaml,
	"csidriveroperators/ovirt/08_cr.yaml":                   csidriveroperatorsOvirt08_crYaml,
	"storageclasses/aws.yaml":                               storageclassesAwsYaml,
	"storageclasses/azure.yaml":                             storageclassesAzureYaml,
	"storageclasses/gcp.yaml":                               storageclassesGcpYaml,
	"storageclasses/openstack.yaml":                         storageclassesOpenstackYaml,
	"storageclasses/vsphere.yaml":                           storageclassesVsphereYaml,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"csidriveroperators": {nil, map[string]*bintree{
		"aws-ebs": {nil, map[string]*bintree{
			"01_namespace.yaml":          {csidriveroperatorsAwsEbs01_namespaceYaml, map[string]*bintree{}},
			"02_sa.yaml":                 {csidriveroperatorsAwsEbs02_saYaml, map[string]*bintree{}},
			"03_role.yaml":               {csidriveroperatorsAwsEbs03_roleYaml, map[string]*bintree{}},
			"04_rolebinding.yaml":        {csidriveroperatorsAwsEbs04_rolebindingYaml, map[string]*bintree{}},
			"05_clusterrole.yaml":        {csidriveroperatorsAwsEbs05_clusterroleYaml, map[string]*bintree{}},
			"06_clusterrolebinding.yaml": {csidriveroperatorsAwsEbs06_clusterrolebindingYaml, map[string]*bintree{}},
			"07_deployment.yaml":         {csidriveroperatorsAwsEbs07_deploymentYaml, map[string]*bintree{}},
			"08_cr.yaml":                 {csidriveroperatorsAwsEbs08_crYaml, map[string]*bintree{}},
		}},
		"manila": {nil, map[string]*bintree{
			"01_namespace.yaml":          {csidriveroperatorsManila01_namespaceYaml, map[string]*bintree{}},
			"02_sa.yaml":                 {csidriveroperatorsManila02_saYaml, map[string]*bintree{}},
			"03_role.yaml":               {csidriveroperatorsManila03_roleYaml, map[string]*bintree{}},
			"04_rolebinding.yaml":        {csidriveroperatorsManila04_rolebindingYaml, map[string]*bintree{}},
			"05_clusterrole.yaml":        {csidriveroperatorsManila05_clusterroleYaml, map[string]*bintree{}},
			"06_clusterrolebinding.yaml": {csidriveroperatorsManila06_clusterrolebindingYaml, map[string]*bintree{}},
			"07_deployment.yaml":         {csidriveroperatorsManila07_deploymentYaml, map[string]*bintree{}},
			"08_cr.yaml":                 {csidriveroperatorsManila08_crYaml, map[string]*bintree{}},
		}},
		"ovirt": {nil, map[string]*bintree{
			"01_namespace.yaml":          {csidriveroperatorsOvirt01_namespaceYaml, map[string]*bintree{}},
			"02_sa.yaml":                 {csidriveroperatorsOvirt02_saYaml, map[string]*bintree{}},
			"03_role.yaml":               {csidriveroperatorsOvirt03_roleYaml, map[string]*bintree{}},
			"04_rolebinding.yaml":        {csidriveroperatorsOvirt04_rolebindingYaml, map[string]*bintree{}},
			"05_clusterrole.yaml":        {csidriveroperatorsOvirt05_clusterroleYaml, map[string]*bintree{}},
			"06_clusterrolebinding.yaml": {csidriveroperatorsOvirt06_clusterrolebindingYaml, map[string]*bintree{}},
			"07_deployment.yaml":         {csidriveroperatorsOvirt07_deploymentYaml, map[string]*bintree{}},
			"08_cr.yaml":                 {csidriveroperatorsOvirt08_crYaml, map[string]*bintree{}},
		}},
	}},
	"storageclasses": {nil, map[string]*bintree{
		"aws.yaml":       {storageclassesAwsYaml, map[string]*bintree{}},
		"azure.yaml":     {storageclassesAzureYaml, map[string]*bintree{}},
		"gcp.yaml":       {storageclassesGcpYaml, map[string]*bintree{}},
		"openstack.yaml": {storageclassesOpenstackYaml, map[string]*bintree{}},
		"vsphere.yaml":   {storageclassesVsphereYaml, map[string]*bintree{}},
	}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}
