-
Notifications
You must be signed in to change notification settings - Fork 55
Clean handling of driver restart #25
Comments
I propose to close this. It does not contain a clear objective to solve. Driver anyway can not decide about the state of volumes, it executes orders from above, and is operating on top of device(s) state. |
Let's keep this open. One possible test scenario is:
|
if, after restart, driver receives node:{stage-publish-unpublish-unstage} sequence for existing VolumeID, the resulting action is good, as Node operates on devices doing thes operations, without keeping in-memory context. |
Restoring complete state after driver restart is interesting topic. |
I had in my mind that persisting driver state to a file on node, may be its the time to consider this. |
Amarnath Valluri <[email protected]> writes:
I had in my mind that persisting driver state to a file on node,
That can't work for a pod that can move between nodes.
may be its the time to consider this.
ceph-csi had the same problem. They solved it by storing data in a
confimap, see ceph/ceph-csi#113
|
Yes i agree, the only thing in my mind is how far a csi driver can have Kubernetes dependency, in that case we could avoid RegistryServer itself completely :) |
Amarnath Valluri <[email protected]> writes:
the only thing in my mind is how far a csi driver can
have Kubernetes dependency,
ceph-csi made that dependency optional by using local files by default
and a configmap only when explicitly enabled.
in that case we could avoid RegistryServer
itself completely :)
True.
|
I made a "node reboot" test in running 4xVM cluster with Clear=28030 and Kubernetes 1.13.3. This happens because in NodeStageVolume (where mkfs is done for newly-created volume), |
same result when rebooting cluster master, looking good |
same result when forcibly stopping, starting entire cluster (make stop, make start) |
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
Upon restarts, driver has to recognize the provisioned volumes on last run. For that driver has to persist its state(provisioned volume information). We have two options: 1. Per node state: Persist the driver state on each node specific to that node. Upon driver start, it has to load the persisted information. Whenever a node registers, Controller/Master has to collect the volume information stored on that node. 2. Cluster level state: Persist the consolidated cluster level driver state, say to a configmap on Kubernetes. This is supposed to done at Controller side, but not clear how to pass node specific information to a node. This change implements the fist option, i.e, per node state. Defined a new interface, StateManager, that handles the state persistency irrespective of either per node or cluster. Also provided an implementation of StateManager that persists the state to a file. Made changes to RegistrySrerver, so that it informs the listeners upon registering of a node controller. The ControllerServer on master, listens on this and collects the volume information on node, by calling csi.ControllerServer.ListVolumes. FIXES intel#25 - Clean handling of driver restart
What is the state of provisioned volumes after driver restart?
Lvolumes may exist, and may be mounted or remain unmounted.
Host maintains that state, but driver may restart.
As driver does not have permanently stored volumes state,
it does not have context after restart, and that means trouble for next operations.
All existing volumes or mounts are orphaned in context of driver.
Driver should try to reach the same, or at least some reasonable state about existing volumes and mounts.
Here, similar to #11, it is also possible that some Lvolumes exist in host context which were not created by PMEM-CSI driver, so driver needs to recognize own vs foreign volumes as well.
The text was updated successfully, but these errors were encountered: