foreman_snapshot_management 1.7.1 → 2.0.0

data/test/controllers/foreman_snapshot_management/snapshots_controller_test.rb

@@ -19,7 +19,7 @@ module ForemanSnapshotManagement
       FactoryBot.create(:proxmox_cr)
       ComputeResource.find_by(type: 'ForemanFogProxmox::Proxmox')
     end
-    let(:vmid) { '100' }
+    let(:vmid) { '1_100' }
     let(:proxmox_host) { FactoryBot.create(:host, :managed, :compute_resource => proxmox_compute_resource, :uuid => vmid) }
     let(:proxmox_snapshot) { 'snapshot1' }
     setup { ::Fog.mock! }

data/test/factories/proxmox_factory.rb

@@ -2,7 +2,7 @@
 
 FactoryBot.define do
   factory :proxmox_resource, :class => ComputeResource do
-    sequence(:name) { |n| "compute_resource#{n}" }
+    sequence(:name) { |n| "compute_resource_proxmox#{n}" }
     organizations { [Organization.find_by(name: 'Organization 1')] }
     locations { [Location.find_by(name: 'Location 1')] }
 

data/webpack/components/SnapshotManagement/SnapshotManagement.js

@@ -0,0 +1,84 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Button } from 'patternfly-react';
+
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import SnapshotFormModal from './components/SnapshotFormModal';
+import useSnapshotFormModal from './components/SnapshotFormModal/useSnapshotFormModal';
+import SnapshotList from './components/SnapshotList/SnapshotList';
+import './snapshotManagement.scss';
+
+const SnapshotManagement = ({ canCreate, host, ...props }) => {
+  const children = [];
+  const { setModalOpen, setModalClosed } = useSnapshotFormModal();
+
+  const onCreateClick = () => {
+    setModalOpen();
+  };
+  const allowedHostAttr = ['id', 'name'];
+  const filteredHost = Object.keys(host)
+    .filter(key => allowedHostAttr.includes(key))
+    .reduce(
+      (obj, key) => ({
+        ...obj,
+        [key]: host[key],
+      }),
+      {}
+    );
+
+  if (canCreate) {
+    children.push(
+      <SnapshotFormModal
+        key="snapshot-form-modal"
+        setModalClosed={setModalClosed}
+        host={filteredHost}
+        hostId={host.id}
+        {...props}
+      />
+    );
+    children.push(
+      <Button
+        key="snapshot-create-button"
+        onClick={onCreateClick}
+        className="snapshot-create"
+      >
+        {__('Create Snapshot')}
+      </Button>
+    );
+  }
+
+  children.push(
+    <SnapshotList key="snapshot-list" host={filteredHost} {...props} />
+  );
+
+  return <div>{children}</div>;
+};
+
+SnapshotManagement.propTypes = {
+  host: PropTypes.shape({
+    id: PropTypes.number.isRequired,
+    name: PropTypes.string.isRequired,
+  }).isRequired,
+  canCreate: PropTypes.bool,
+  canUpdate: PropTypes.bool,
+  canRevert: PropTypes.bool,
+  canDelete: PropTypes.bool,
+  capabilities: PropTypes.shape({
+    editSnapshotName: PropTypes.bool,
+    limitSnapshotNameFormat: PropTypes.bool,
+  }),
+};
+
+SnapshotManagement.defaultProps = {
+  canCreate: false,
+  canUpdate: false,
+  canRevert: false,
+  canDelete: false,
+  capabilities: {
+    editSnapshotName: true,
+    limitSnapshotNameFormat: false,
+  },
+};
+
+export default SnapshotManagement;

data/webpack/components/SnapshotManagement/SnapshotManagementActions.js

@@ -0,0 +1,212 @@
+import { API, actionTypeGenerator } from 'foremanReact/redux/API';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
+import { addToast } from 'foremanReact/redux/actions/toasts';
+
+import {
+  SNAPSHOT_LIST,
+  SNAPSHOT_LIST_URL,
+  SNAPSHOT_DELETE,
+  SNAPSHOT_DELETE_URL,
+  SNAPSHOT_UPDATE,
+  SNAPSHOT_UPDATE_URL,
+  SNAPSHOT_ROLLBACK,
+  SNAPSHOT_ROLLBACK_URL,
+} from './SnapshotManagementConstants';
+
+export const loadSnapshotList = hostId => async dispatch => {
+  const { REQUEST, SUCCESS, FAILURE } = actionTypeGenerator(SNAPSHOT_LIST);
+
+  dispatch({
+    type: REQUEST,
+    payload: { hostId },
+  });
+  try {
+    const { data } = await API.get(
+      SNAPSHOT_LIST_URL.replace(':host_id', hostId)
+    );
+    return dispatch({
+      type: SUCCESS,
+      payload: { hostId },
+      response: data,
+    });
+  } catch (error) {
+    return dispatch({
+      type: FAILURE,
+      payload: { hostId },
+      response: error,
+    });
+  }
+};
+
+export const snapshotDeleteAction = (host, rowData) => async dispatch => {
+  const { REQUEST, SUCCESS, FAILURE } = actionTypeGenerator(SNAPSHOT_DELETE);
+
+  dispatch({
+    type: REQUEST,
+    payload: {
+      host,
+      id: rowData.id,
+    },
+  });
+  try {
+    const { data } = await API.delete(
+      sprintf(SNAPSHOT_DELETE_URL, host.id, rowData.id)
+    );
+
+    dispatch(
+      addToast({
+        type: 'success',
+        message: sprintf(
+          __('Successfully removed Snapshot "%s" from host %s'),
+          rowData.name,
+          host.name
+        ),
+        key: SUCCESS,
+      })
+    );
+    dispatch(loadSnapshotList(host.id));
+    return dispatch({
+      type: SUCCESS,
+      payload: {
+        host,
+        id: rowData.id,
+      },
+      response: data,
+    });
+  } catch (error) {
+    dispatch(
+      addToast({
+        type: 'error',
+        message: sprintf(
+          __('Error occurred while removing Snapshot: %s'),
+          error
+        ),
+        key: FAILURE,
+      })
+    );
+    return dispatch({
+      type: FAILURE,
+      payload: {
+        host,
+        id: rowData.id,
+      },
+      response: error,
+    });
+  }
+};
+
+export const snapshotUpdateAction = (host, rowData) => async dispatch => {
+  const { REQUEST, SUCCESS, FAILURE } = actionTypeGenerator(SNAPSHOT_UPDATE);
+
+  dispatch({
+    type: REQUEST,
+    payload: {
+      host,
+      id: rowData.id,
+      snapshot: {
+        name: rowData.name,
+        description: rowData.description,
+      },
+    },
+  });
+  try {
+    const { data } = await API.put(
+      sprintf(SNAPSHOT_UPDATE_URL, host.id, rowData.id),
+      {
+        snapshot: {
+          name: rowData.name,
+          description: rowData.description,
+        },
+      }
+    );
+    dispatch(
+      addToast({
+        type: 'success',
+        message: sprintf(
+          __('Successfully updated Snapshot "%s"'),
+          rowData.name
+        ),
+        key: SUCCESS,
+      })
+    );
+    return dispatch({
+      type: SUCCESS,
+      payload: {
+        host,
+        id: rowData.id,
+      },
+      response: data,
+    });
+  } catch (error) {
+    dispatch(
+      addToast({
+        type: 'error',
+        message: sprintf(
+          __('Error occurred while updating Snapshot: %s'),
+          error
+        ),
+        key: FAILURE,
+      })
+    );
+    return dispatch({
+      type: FAILURE,
+      payload: {
+        host,
+        id: rowData.id,
+      },
+      response: error,
+    });
+  }
+};
+
+export const snapshotRollbackAction = (host, rowData) => async dispatch => {
+  const { REQUEST, SUCCESS, FAILURE } = actionTypeGenerator(SNAPSHOT_ROLLBACK);
+
+  dispatch({
+    type: REQUEST,
+    payload: {
+      host,
+      id: rowData.id,
+    },
+  });
+  try {
+    const { data } = await API.put(
+      sprintf(SNAPSHOT_ROLLBACK_URL, host.id, rowData.id)
+    );
+    dispatch(
+      addToast({
+        type: 'success',
+        message: sprintf(
+          __('Successfully rolled back Snapshot "%s" on host %s'),
+          rowData.name,
+          host.name
+        ),
+        key: SUCCESS,
+      })
+    );
+    return dispatch({
+      type: SUCCESS,
+      payload: {
+        host,
+        id: rowData.id,
+      },
+      response: data,
+    });
+  } catch (error) {
+    dispatch(
+      addToast({
+        type: 'error',
+        message: sprintf(__('Error occurred while rolling back VM: %s'), error),
+        key: FAILURE,
+      })
+    );
+    return dispatch({
+      type: FAILURE,
+      payload: {
+        host,
+        id: rowData.id,
+      },
+      response: error,
+    });
+  }
+};

data/webpack/components/SnapshotManagement/SnapshotManagementConstants.js

@@ -0,0 +1,9 @@
+export const SNAPSHOT_LIST = 'FOREMAN_SNAPSHOT_MANAGEMENT_SNAPSHOT_LIST';
+export const SNAPSHOT_LIST_URL = '/api/hosts/:host_id/snapshots/';
+export const SNAPSHOT_DELETE = 'FOREMAN_SNAPSHOT_MANAGEMENT_SNAPSHOT_DELETE';
+export const SNAPSHOT_DELETE_URL = '/api/hosts/%s/snapshots/%s/';
+export const SNAPSHOT_UPDATE = 'FOREMAN_SNAPSHOT_MANAGEMENT_SNAPSHOT_UPDATE';
+export const SNAPSHOT_UPDATE_URL = '/api/hosts/%s/snapshots/%s/';
+export const SNAPSHOT_ROLLBACK =
+  'FOREMAN_SNAPSHOT_MANAGEMENT_SNAPSHOT_ROLLBACK';
+export const SNAPSHOT_ROLLBACK_URL = '/api/hosts/%s/snapshots/%s/revert';

data/webpack/components/SnapshotManagement/SnapshotManagementReducer.js

@@ -0,0 +1,100 @@
+// This is an example for a generic redux's reducer
+// Reducers should be registered to foreman-core
+// For a further registration demonstration, have a look in `webpack/global_index.js`
+
+import Immutable from 'seamless-immutable';
+import { cloneDeep, findIndex } from 'lodash';
+
+import { actionTypeGenerator } from 'foremanReact/redux/API';
+
+import {
+  SNAPSHOT_LIST,
+  SNAPSHOT_DELETE,
+  SNAPSHOT_UPDATE,
+  SNAPSHOT_ROLLBACK,
+} from './SnapshotManagementConstants';
+
+export const initialState = Immutable({
+  isLoading: true,
+  isWorking: false,
+  hasError: false,
+  snapshots: [],
+});
+
+export default (state = initialState, action) => {
+  const { response } = action;
+
+  const listTypes = actionTypeGenerator(SNAPSHOT_LIST);
+  const deleteTypes = actionTypeGenerator(SNAPSHOT_DELETE);
+  const updateTypes = actionTypeGenerator(SNAPSHOT_UPDATE);
+  const rollbackTypes = actionTypeGenerator(SNAPSHOT_ROLLBACK);
+
+  switch (action.type) {
+    case 'SNAPSHOT_FORM_SUBMITTED':
+      return state.merge({
+        needsReload: true,
+      });
+    case listTypes.REQUEST:
+      return state.merge({
+        snapshots: [],
+        isLoading: true,
+        hasError: false,
+        needsReload: false,
+      });
+    case listTypes.SUCCESS:
+      return state.merge({
+        snapshots: response.results,
+        isLoading: false,
+        needsReload: false,
+      });
+    case listTypes.FAILURE:
+      return state.merge({
+        error: response,
+        hasError: true,
+        isLoading: false,
+        needsReload: false,
+      });
+    case deleteTypes.REQUEST:
+      return state.merge({
+        isWorking: true,
+      });
+    case deleteTypes.SUCCESS:
+    case deleteTypes.FAILURE:
+      return state.merge({
+        isWorking: false,
+      });
+    case updateTypes.REQUEST:
+      return state.merge({
+        isWorking: true,
+      });
+    case updateTypes.SUCCESS: {
+      const snapshots = cloneDeep(state.snapshots);
+      const index = findIndex(snapshots, { id: response.id });
+
+      snapshots[index].name = response.name;
+      snapshots[index].description = response.description;
+
+      return state.merge({
+        isWorking: false,
+        snapshots,
+      });
+    }
+    case updateTypes.FAILURE:
+      return state.merge({
+        isWorking: false,
+      });
+    case rollbackTypes.REQUEST:
+      return state.merge({
+        snapshots: state.snapshots,
+        isWorking: true,
+      });
+    case rollbackTypes.SUCCESS:
+    case rollbackTypes.FAILURE:
+      return state.merge({
+        snapshots: state.snapshots,
+        isWorking: false,
+      });
+    default:
+      return state;
+  }
+};

data/webpack/components/SnapshotManagement/SnapshotManagementSelectors.js

@@ -0,0 +1,8 @@
+const snapshotMgmt = state => state.foremanSnapshotManagement;
+
+export const selectSnapshots = state => snapshotMgmt(state).snapshots;
+export const selectIsLoading = state => snapshotMgmt(state).isLoading;
+export const selectIsWorking = state => snapshotMgmt(state).isWorking;
+export const selectHasError = state => snapshotMgmt(state).hasError;
+export const selectError = state => snapshotMgmt(state).error;
+export const selectNeedsReload = state => snapshotMgmt(state).needsReload;

data/webpack/components/SnapshotManagement/__tests__/SnapshotManagementActions.test.js

@@ -0,0 +1,123 @@
+import { testActionSnapshotWithFixtures } from 'react-redux-test-utils';
+import { API } from 'foremanReact/redux/API';
+
+import {
+  loadSnapshotList,
+  snapshotDeleteAction,
+  snapshotRollbackAction,
+  snapshotUpdateAction,
+} from '../SnapshotManagementActions';
+
+jest.mock('foremanReact/redux/API/API');
+
+const successResponse = {
+  data: 'some-data',
+};
+
+const doLoadSnapshotList = (hostId, serverMock) => {
+  API.get.mockImplementation(serverMock);
+
+  return loadSnapshotList(hostId);
+};
+
+const doDeleteSnapshot = (host, rowData, serverMock) => {
+  API.delete.mockImplementation(serverMock);
+
+  return snapshotDeleteAction(host, rowData);
+};
+
+const doRollbackSnapshot = (host, rowData, serverMock) => {
+  API.put.mockImplementation(serverMock);
+
+  return snapshotRollbackAction(host, rowData);
+};
+
+const doUpdateSnapshot = (host, rowData, serverMock) => {
+  API.put.mockImplementation(serverMock);
+
+  return snapshotUpdateAction(host, rowData);
+};
+
+const listFixtures = {
+  'should load snapshots and success': () =>
+    doLoadSnapshotList(42, async () => successResponse),
+
+  'should load snapshots and fail': () =>
+    doLoadSnapshotList(42, async () => {
+      throw new Error('some-error');
+    }),
+};
+
+describe('Snapshot list actions', () =>
+  testActionSnapshotWithFixtures(listFixtures));
+
+const deleteFixtures = {
+  'should delete snapshot and success': () =>
+    doDeleteSnapshot(
+      { id: 42, name: 'deep.thought' },
+      { id: 'snapshot-0815', name: 'Savegame' },
+      async () => successResponse
+    ),
+
+  'should load snapshots and fail': () =>
+    doDeleteSnapshot(
+      { id: 42, name: 'deep.thought' },
+      { id: 'snapshot-0815', name: 'Savegame' },
+      async () => {
+        throw new Error('some-error');
+      }
+    ),
+};
+
+describe('Snapshot snapshot-delete actions', () =>
+  testActionSnapshotWithFixtures(deleteFixtures));
+
+const rollbackFixtures = {
+  'should rollback snapshot and success': () =>
+    doRollbackSnapshot(
+      { id: 42, name: 'deep.thought' },
+      { id: 'snapshot-0815', name: 'Savegame' },
+      async () => successResponse
+    ),
+
+  'should load snapshots and fail': () =>
+    doRollbackSnapshot(
+      { id: 42, name: 'deep.thought' },
+      { id: 'snapshot-0815', name: 'Savegame' },
+      async () => {
+        throw new Error('some-error');
+      }
+    ),
+};
+
+describe('Snapshot snapshot-rollback actions', () =>
+  testActionSnapshotWithFixtures(rollbackFixtures));
+
+const updateFixtures = {
+  'should update snapshot and success': () =>
+    doUpdateSnapshot(
+      { id: 42, name: 'deep.thought' },
+      {
+        id: 'snapshot-0815',
+        name: 'Savegame',
+        description: 'Saw the three headed monkey!',
+      },
+      async () => successResponse
+    ),
+
+  'should load snapshots and fail': () =>
+    doUpdateSnapshot(
+      { id: 42, name: 'deep.thought' },
+      {
+        id: 'snapshot-0815',
+        name: 'Savegame',
+        description: 'Saw the three headed monkey!',
+      },
+      async () => {
+        throw new Error('some-error');
+      }
+    ),
+};
+
+describe('Snapshot snapshot-update actions', () =>
+  testActionSnapshotWithFixtures(updateFixtures));