Skip to content
This repository has been archived by the owner on Oct 22, 2024. It is now read-only.

Clean handling of driver restart #25

Closed
okartau opened this issue Oct 19, 2018 · 11 comments · Fixed by #196
Closed

Clean handling of driver restart #25

okartau opened this issue Oct 19, 2018 · 11 comments · Fixed by #196

Comments

@okartau
Copy link
Contributor

okartau commented Oct 19, 2018

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.

@okartau
Copy link
Contributor Author

okartau commented Nov 28, 2018

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.

@pohly
Copy link
Contributor

pohly commented Nov 28, 2018

Let's keep this open. One possible test scenario is:

  • create a PVC
  • create an app that uses the PVC
  • restart the cluster
  • wait for app to restart
  • delete app
  • delete PVC

@okartau
Copy link
Contributor Author

okartau commented Jan 11, 2019

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.
But Controller-Create/Delete are problematic after restart, as Controller operates on in-memory registry of Volumes which is not re-created after restart. Means, when receiving a next create with existing volume name, it will attempt new creation, and when receiving Delete, it responds with "not created by this controller"

@okartau
Copy link
Contributor Author

okartau commented Jan 11, 2019

Restoring complete state after driver restart is interesting topic.
Controller in-memory registry restore is not currently implemented, and would require some effort, as
Controller either needs to store it's registry in NV storage (complex as it's not fixed defined where it runs), or needs to recreate volumes information by collecting information from Nodes. That's probably doable, but poses some challenges, and some bits of data now in registry, are not stored in namespace information, like erasemode (added by us in this driver). Erasemode starts to look like troublemaker, would it be simpler just to forget about it and always wipe all data after volume deletion.

@avalluri
Copy link
Contributor

I had in my mind that persisting driver state to a file on node, may be its the time to consider this.

@pohly
Copy link
Contributor

pohly commented Jan 11, 2019 via email

@avalluri
Copy link
Contributor

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 :)

@pohly
Copy link
Contributor

pohly commented Jan 11, 2019 via email

@okartau
Copy link
Contributor Author

okartau commented Feb 27, 2019

I made a "node reboot" test in running 4xVM cluster with Clear=28030 and Kubernetes 1.13.3.
Deployment is made according to README example steps (Devicemode:direct).
With my-csi-app running and using provisioned volume on node-1, I rebooted that node.
node-1 status changed to Error for some time, then back to Running.
Restarted pmem-csi on node-1 received NodeStageVolume, and NodePublishVolume,
then application reached the state using previously existing files system.

This happens because in NodeStageVolume (where mkfs is done for newly-created volume),
there is check for existing file system. If the existing file system type is same as requested,
mkfs is skipped.
(if fstype is different then error is returned, and only if there is no file system, we perform mkfs)

@okartau
Copy link
Contributor Author

okartau commented Feb 27, 2019

same result when rebooting cluster master, looking good

@okartau
Copy link
Contributor Author

okartau commented Feb 27, 2019

same result when forcibly stopping, starting entire cluster (make stop, make start)

avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 14, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 14, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 14, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 14, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 15, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 15, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 15, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 18, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 20, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 20, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 20, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 25, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 25, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Mar 25, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Apr 5, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Apr 5, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Apr 24, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Apr 25, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Apr 25, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue May 2, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue May 10, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue May 17, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue May 17, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 6, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 19, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 22, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 25, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 27, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 27, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 27, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 28, 2019
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
avalluri added a commit to avalluri/pmem-CSI that referenced this issue Jun 28, 2019
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
@pohly pohly closed this as completed in #196 Jul 1, 2019
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Labels
None yet
Projects
None yet
Development

Successfully merging a pull request may close this issue.

3 participants