484 lines
14 KiB
JavaScript
484 lines
14 KiB
JavaScript
import React from 'react';
|
|
import './MountItems.css';
|
|
import AddMount from '../AddMount/AddMount';
|
|
import Box from '../../components/UI/Box/Box';
|
|
import Button from '../../components/UI/Button/Button';
|
|
import IPCContainer from '../IPCContainer/IPCContainer';
|
|
import Modal from '../../components/UI/Modal/Modal';
|
|
import MountItem from './MountItem/MountItem';
|
|
import {connect} from 'react-redux';
|
|
import {notifyError} from '../../redux/actions/error_actions';
|
|
import {
|
|
resetMountsState,
|
|
setAllowMount,
|
|
setAutoMountProcessed,
|
|
setBusy,
|
|
setMounted,
|
|
setMountState,
|
|
setProviderState,
|
|
} from '../../redux/actions/mount_actions';
|
|
|
|
const Constants = require('../../constants');
|
|
|
|
class MountItems extends IPCContainer {
|
|
retryIntervals = {};
|
|
activeDetections = [];
|
|
|
|
state = {
|
|
DisplayRetry: false,
|
|
RetryItems: {},
|
|
};
|
|
|
|
addMountsBusy = (provider) => {
|
|
this.props.setMountsBusy(true);
|
|
this.activeDetections.push(provider);
|
|
};
|
|
|
|
cancelRetryMount = (provider, stateCallback) => {
|
|
clearInterval(this.retryIntervals[provider]);
|
|
delete this.retryIntervals[provider];
|
|
|
|
if (stateCallback) {
|
|
let retryItems = {
|
|
...this.state.RetryItems,
|
|
};
|
|
delete retryItems[provider];
|
|
this.setState(
|
|
{
|
|
DisplayRetry: Object.keys(retryItems).length > 0,
|
|
RetryItems: retryItems,
|
|
},
|
|
() => {
|
|
if (this.state.DisplayRetry) {
|
|
this.sendRequest(Constants.IPC_Show_Window);
|
|
}
|
|
stateCallback();
|
|
}
|
|
);
|
|
}
|
|
};
|
|
|
|
componentDidMount() {
|
|
this.setRequestHandler(Constants.IPC_Detect_Mount_Reply, this.onDetectMountReply);
|
|
this.setRequestHandler(Constants.IPC_Mount_Drive_Reply, this.onMountDriveReply);
|
|
this.setRequestHandler(Constants.IPC_Unmount_Drive_Reply, this.onUnmountDriveReply);
|
|
this.props.resetMountsState();
|
|
this.detectMounts();
|
|
}
|
|
|
|
componentWillUnmount() {
|
|
Object.keys(this.state.RetryItems).forEach((provider) => {
|
|
this.cancelRetryMount(provider);
|
|
});
|
|
|
|
this.props.resetMountsState();
|
|
this.activeDetections = [];
|
|
super.componentWillUnmount();
|
|
}
|
|
|
|
detectMount = (provider) => {
|
|
this.addMountsBusy(provider);
|
|
|
|
this.sendRequest(Constants.IPC_Detect_Mount, {
|
|
RemoteMounts: this.props.RemoteMounts,
|
|
S3Mounts: this.props.S3Mounts,
|
|
Provider: provider,
|
|
Version: this.props.InstalledVersion,
|
|
});
|
|
};
|
|
|
|
detectMounts = () => {
|
|
if (!this.state.DisplayRetry) {
|
|
this.getProviderList().forEach((provider) => {
|
|
this.detectMount(provider);
|
|
});
|
|
}
|
|
};
|
|
|
|
displayRetryMount = (provider, remote, s3, mountLocation, msg) => {
|
|
if (!this.state.RetryItems[provider]) {
|
|
let retryItems = {
|
|
...this.state.RetryItems,
|
|
};
|
|
retryItems[provider] = {
|
|
RetrySeconds: 10,
|
|
RetryMessage: msg ? msg.toString() : null,
|
|
};
|
|
const mountState = {
|
|
AllowMount: false,
|
|
Mounted: false,
|
|
};
|
|
this.props.setMountState(provider, mountState);
|
|
|
|
this.setState(
|
|
{
|
|
DisplayRetry: true,
|
|
RetryItems: retryItems,
|
|
},
|
|
() => {
|
|
this.sendRequest(Constants.IPC_Show_Window);
|
|
this.retryIntervals[provider] = setInterval(() => {
|
|
const retryItems = {
|
|
...this.state.RetryItems,
|
|
};
|
|
const retrySeconds = retryItems[provider].RetrySeconds - 1;
|
|
if (retrySeconds === 0) {
|
|
this.cancelRetryMount(provider, () => {
|
|
this.handleMountUnMount(provider, remote, s3, true, mountLocation);
|
|
});
|
|
} else {
|
|
retryItems[provider].RetrySeconds = retrySeconds;
|
|
this.setState({
|
|
RetryItems: retryItems,
|
|
});
|
|
}
|
|
}, 1000);
|
|
}
|
|
);
|
|
}
|
|
};
|
|
|
|
handleBrowseLocation = (provider, location) => {
|
|
location = this.sendSyncRequest(Constants.IPC_Browse_Directory, {
|
|
Title: provider + ' Mount Location',
|
|
Location: location,
|
|
});
|
|
if (location && location.length > 0) {
|
|
this.handleMountLocationChanged(provider, location);
|
|
}
|
|
};
|
|
|
|
handleMountLocationChanged = (provider, mountLocation) => {
|
|
const state = {
|
|
...this.props.ProviderState[provider],
|
|
MountLocation: mountLocation,
|
|
};
|
|
this.props.setProviderState(provider, state);
|
|
};
|
|
|
|
handleMountUnMount = (provider, remote, s3, mount, location) => {
|
|
if (!location || location.trim().length === 0) {
|
|
this.props.notifyError('Mount location is not set');
|
|
} else {
|
|
let allowAction = true;
|
|
if (mount) {
|
|
let result =
|
|
remote || s3 || provider === 'Skynet'
|
|
? {Valid: true, Success: true}
|
|
: this.sendSyncRequest(Constants.IPC_Check_Daemon_Version, {
|
|
Provider: provider,
|
|
Remote: remote,
|
|
S3: s3,
|
|
Version: this.props.InstalledVersion,
|
|
}).data;
|
|
const displayRetry = (msg) => {
|
|
this.displayRetryMount(provider, remote, s3, location, msg);
|
|
};
|
|
if (result.Success) {
|
|
if (result.Valid) {
|
|
if (this.props.Platform !== 'win32') {
|
|
result = this.sendSyncRequest(Constants.IPC_Check_Mount_Location, {
|
|
Location: location,
|
|
});
|
|
if (!result.Success) {
|
|
allowAction = false;
|
|
this.props.notifyError(result.Error.toString());
|
|
}
|
|
}
|
|
} else {
|
|
allowAction = false;
|
|
if (
|
|
result.Code === new Uint32Array([-1])[0] ||
|
|
result.Code === new Uint8Array([-1])[0]
|
|
) {
|
|
displayRetry('Failed to connect to ' + provider + ' daemon');
|
|
} else if (
|
|
result.Code === new Uint32Array([-3])[0] ||
|
|
result.Code === new Uint8Array([-3])[0]
|
|
) {
|
|
displayRetry(
|
|
'Incompatible ' + provider + ' daemon. Please upgrade ' + provider + '.'
|
|
);
|
|
} else {
|
|
displayRetry('Version check failed: ' + result.Error);
|
|
}
|
|
}
|
|
} else {
|
|
allowAction = false;
|
|
if (this.props.Platform === 'win32') {
|
|
this.props.notifyError(
|
|
'Failed to launch repertory. Please install Microsoft Visual C++ Redistributable for Visual Studio 2015, 2017 and 2019.'
|
|
);
|
|
} else {
|
|
displayRetry('Version check failed: ' + result.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allowAction) {
|
|
this.addMountsBusy(provider);
|
|
this.props.setAllowMount(provider, false);
|
|
|
|
this.sendRequest(mount ? Constants.IPC_Mount_Drive : Constants.IPC_Unmount_Drive, {
|
|
Location: location,
|
|
Provider: provider,
|
|
Remote: remote,
|
|
S3: s3,
|
|
Version: this.props.InstalledVersion,
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
getProviderList = (providersOnly) => {
|
|
const providerList = Constants.PROVIDER_LIST.filter((i) => {
|
|
return (
|
|
(i === 'Skynet' && this.props.skynetSupported) ||
|
|
(i === 'ScPrime' && this.props.scPrimeSupported) ||
|
|
(i === 'Sia' && this.props.siaSupported)
|
|
);
|
|
});
|
|
|
|
let remoteList = [];
|
|
if (this.props.remoteSupported && !providersOnly) {
|
|
remoteList = [...this.props.RemoteMounts];
|
|
}
|
|
|
|
let s3List = [];
|
|
if (this.props.s3Supported && !providersOnly) {
|
|
s3List = [...this.props.S3Mounts];
|
|
}
|
|
|
|
return [...providerList, ...remoteList, ...s3List];
|
|
};
|
|
|
|
hasActiveMount = () => {
|
|
return !!Object.keys(this.props.MountState).find((provider) => {
|
|
return this.props.MountState[provider].Mounted;
|
|
});
|
|
};
|
|
|
|
onDetectMountReply = (_, arg) => {
|
|
const provider = arg.data.Provider;
|
|
if (!this.state.RetryItems[provider]) {
|
|
if (
|
|
arg.data.Success &&
|
|
(!arg.data.Active || (arg.data.Location && arg.data.Location.length > 0))
|
|
) {
|
|
const mountState = {
|
|
AllowMount: true,
|
|
DriveLetters: arg.data.DriveLetters,
|
|
Mounted: arg.data.Active,
|
|
};
|
|
this.props.setMountState(provider, mountState);
|
|
|
|
this.updateMountLocation(
|
|
provider,
|
|
arg.data.Location,
|
|
mountState.Mounted,
|
|
arg.data.DriveLetters
|
|
);
|
|
this.props.setAutoMountProcessed(provider, true);
|
|
this.removeMountsBusy(provider);
|
|
} else {
|
|
this.detectMount(provider);
|
|
this.removeMountsBusy(provider);
|
|
}
|
|
}
|
|
};
|
|
|
|
onMountDriveReply = (_, arg) => {
|
|
this.props.setMounted(arg.data.Provider, arg.data.Success);
|
|
this.detectMount(arg.data.Provider);
|
|
this.removeMountsBusy(arg.data.Provider);
|
|
};
|
|
|
|
onUnmountDriveReply = (_, arg) => {
|
|
if (
|
|
arg &&
|
|
arg.data &&
|
|
!arg.data.Expected &&
|
|
arg.data.Location &&
|
|
this.props.ProviderState[arg.data.Provider].AutoRestart
|
|
) {
|
|
this.displayRetryMount(arg.data.Provider, arg.data.Remote, arg.data.Location);
|
|
} else {
|
|
this.detectMount(arg.data.Provider);
|
|
}
|
|
this.removeMountsBusy(arg.data.Provider);
|
|
};
|
|
|
|
removeMountsBusy = (provider) => {
|
|
const idx = this.activeDetections.indexOf(provider);
|
|
if (idx > -1) {
|
|
this.activeDetections.splice(idx, 1);
|
|
}
|
|
this.props.setMountsBusy(this.activeDetections.length > 0 || this.hasActiveMount());
|
|
};
|
|
|
|
updateMountLocation = (provider, location, mounted, driveLetters) => {
|
|
const providerState = this.props.ProviderState[provider];
|
|
if (location.length === 0) {
|
|
location =
|
|
this.props.Platform === 'win32'
|
|
? !providerState.MountLocation || providerState.MountLocation.trim().length === 0
|
|
? driveLetters[0]
|
|
: providerState.MountLocation
|
|
: providerState.MountLocation;
|
|
}
|
|
|
|
if (location !== providerState.MountLocation) {
|
|
this.handleMountLocationChanged(provider, location);
|
|
}
|
|
|
|
if (
|
|
!this.props.AutoMountProcessed[provider] &&
|
|
this.props.ProviderState[provider].AutoMount &&
|
|
!mounted &&
|
|
location.length > 0
|
|
) {
|
|
this.handleMountUnMount(
|
|
provider,
|
|
this.props.RemoteMounts.includes(provider),
|
|
this.props.S3Mounts.includes(provider),
|
|
true,
|
|
location
|
|
);
|
|
}
|
|
};
|
|
|
|
render() {
|
|
let retryDisplay;
|
|
if (this.state.DisplayRetry) {
|
|
const retryList = [];
|
|
let retryCount = 0;
|
|
Object.keys(this.state.RetryItems).forEach((provider) => {
|
|
if (this.state.RetryItems[provider].RetryMessage) {
|
|
retryList.push(
|
|
<p key={'rl_' + retryList.length}>{this.state.RetryItems[provider].RetryMessage}</p>
|
|
);
|
|
}
|
|
retryList.push(
|
|
<Button
|
|
clicked={() => this.cancelRetryMount(provider, () => this.detectMounts())}
|
|
key={'rl_' + retryList.length}>
|
|
Cancel {provider} Remount ({this.state.RetryItems[provider].RetrySeconds}s)
|
|
</Button>
|
|
);
|
|
if (++retryCount < Object.keys(this.state.RetryItems).length) {
|
|
retryList.push(
|
|
<div style={{paddingTop: 'var(--default_spacing)'}} key={'rl_' + retryList.length}/>
|
|
);
|
|
}
|
|
});
|
|
|
|
retryDisplay = (
|
|
<Modal>
|
|
<Box dxDark dxStyle={{padding: 'var(--default_spacing)', minWidth: '70vw'}}>
|
|
<h1
|
|
style={{
|
|
textAlign: 'center',
|
|
paddingBottom: 'var(--default_spacing)',
|
|
color: 'var(--text_color_error)',
|
|
}}>
|
|
Mount Failed
|
|
</h1>
|
|
{retryList}
|
|
</Box>
|
|
</Modal>
|
|
);
|
|
}
|
|
|
|
const footerItems = [];
|
|
if (this.props.remoteSupported || this.props.s3Supported) {
|
|
footerItems.push(
|
|
<AddMount
|
|
remoteSupported={this.props.remoteSupported}
|
|
s3Supported={this.props.s3Supported}
|
|
key={'hi_' + footerItems.length}
|
|
/>
|
|
);
|
|
} else {
|
|
footerItems.push(<div key={'hi_' + footerItems.length} style={{height: '27px'}}/>);
|
|
}
|
|
|
|
const mountItems = [];
|
|
const addMountItem = (provider, remote, s3) => {
|
|
if (mountItems.length > 0) {
|
|
mountItems.push(
|
|
<div
|
|
key={'it_' + mountItems.length}
|
|
style={{paddingTop: 'calc(var(--default_spacing) * 2.5)'}}
|
|
/>
|
|
);
|
|
}
|
|
|
|
mountItems.push(
|
|
<MountItem
|
|
allowRemove={remote || s3}
|
|
browseClicked={this.handleBrowseLocation}
|
|
changed={(e) => this.handleMountLocationChanged(provider, e.target.value)}
|
|
clicked={this.handleMountUnMount}
|
|
key={'it_' + mountItems.length}
|
|
provider={provider}
|
|
remote={remote}
|
|
s3={s3}
|
|
/>
|
|
);
|
|
};
|
|
|
|
this.getProviderList(true).forEach((provider) => addMountItem(provider));
|
|
|
|
if (this.props.remoteSupported) {
|
|
this.props.RemoteMounts.forEach((provider) => addMountItem(provider, true));
|
|
}
|
|
|
|
if (this.props.s3Supported) {
|
|
this.props.S3Mounts.forEach((provider) => addMountItem(provider, false, true));
|
|
}
|
|
|
|
return (
|
|
<div style={{margin: 0, padding: 0}}>
|
|
{retryDisplay}
|
|
<div
|
|
className={
|
|
this.props.remoteSupported || this.props.s3Supported ? 'MountItemsRemote' : 'MountItems'
|
|
}>
|
|
{mountItems}
|
|
</div>
|
|
<div style={{paddingTop: 'var(--default_spacing)'}}/>
|
|
{footerItems}
|
|
</div>
|
|
);
|
|
}
|
|
}
|
|
|
|
const mapStateToProps = (state) => {
|
|
return {
|
|
AutoMountProcessed: state.mounts.AutoMountProcessed,
|
|
InstalledVersion: state.relver.InstalledVersion,
|
|
MountState: state.mounts.MountState,
|
|
MountsBusy: state.mounts.MountsBusy,
|
|
Platform: state.common.Platform,
|
|
ProviderState: state.mounts.ProviderState,
|
|
RemoteMounts: state.mounts.RemoteMounts,
|
|
S3Mounts: state.mounts.S3Mounts,
|
|
};
|
|
};
|
|
|
|
const mapDispatchToProps = (dispatch) => {
|
|
return {
|
|
notifyError: (msg, critical, callback) => dispatch(notifyError(msg, critical, callback)),
|
|
resetMountsState: () => dispatch(resetMountsState()),
|
|
setAllowMount: (provider, allow) => dispatch(setAllowMount(provider, allow)),
|
|
setAutoMountProcessed: (provider, processed) =>
|
|
dispatch(setAutoMountProcessed(provider, processed)),
|
|
setMounted: (provider, mounted) => dispatch(setMounted(provider, mounted)),
|
|
setMountsBusy: (busy) => dispatch(setBusy(busy)),
|
|
setMountState: (provider, state) => dispatch(setMountState(provider, state)),
|
|
setProviderState: (provider, state) => dispatch(setProviderState(provider, state)),
|
|
};
|
|
};
|
|
|
|
export default connect(mapStateToProps, mapDispatchToProps)(MountItems);
|