mirror of
https://github.com/minio/minio.git
synced 2024-12-26 23:25:54 -05:00
465 lines
13 KiB
JavaScript
465 lines
13 KiB
JavaScript
/*
|
|
* MinIO Cloud Storage (C) 2018 MinIO, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import web from "../web"
|
|
import history from "../history"
|
|
import {
|
|
sortObjectsByName,
|
|
sortObjectsBySize,
|
|
sortObjectsByDate,
|
|
} from "../utils"
|
|
import { getCurrentBucket } from "../buckets/selectors"
|
|
import { getCurrentPrefix, getCheckedList } from "./selectors"
|
|
import * as alertActions from "../alert/actions"
|
|
import {
|
|
minioBrowserPrefix,
|
|
SORT_BY_NAME,
|
|
SORT_BY_SIZE,
|
|
SORT_BY_LAST_MODIFIED,
|
|
SORT_ORDER_ASC,
|
|
SORT_ORDER_DESC,
|
|
} from "../constants"
|
|
import { getServerInfo, hasServerPublicDomain } from '../browser/selectors'
|
|
|
|
export const SET_LIST = "objects/SET_LIST"
|
|
export const RESET_LIST = "objects/RESET_LIST"
|
|
export const SET_FILTER = "objects/SET_FILTER"
|
|
export const APPEND_LIST = "objects/APPEND_LIST"
|
|
export const REMOVE = "objects/REMOVE"
|
|
export const SET_SORT_BY = "objects/SET_SORT_BY"
|
|
export const SET_SORT_ORDER = "objects/SET_SORT_ORDER"
|
|
export const SET_CURRENT_PREFIX = "objects/SET_CURRENT_PREFIX"
|
|
export const SET_PREFIX_WRITABLE = "objects/SET_PREFIX_WRITABLE"
|
|
export const SET_SHARE_OBJECT = "objects/SET_SHARE_OBJECT"
|
|
export const CHECKED_LIST_ADD = "objects/CHECKED_LIST_ADD"
|
|
export const CHECKED_LIST_REMOVE = "objects/CHECKED_LIST_REMOVE"
|
|
export const CHECKED_LIST_RESET = "objects/CHECKED_LIST_RESET"
|
|
export const SET_LIST_LOADING = "objects/SET_LIST_LOADING"
|
|
|
|
export const setList = (objects) => ({
|
|
type: SET_LIST,
|
|
objects,
|
|
})
|
|
|
|
export const resetList = () => ({
|
|
type: RESET_LIST,
|
|
})
|
|
|
|
export const setFilter = filter => {
|
|
return {
|
|
type: SET_FILTER,
|
|
filter
|
|
}
|
|
}
|
|
|
|
export const setListLoading = (listLoading) => ({
|
|
type: SET_LIST_LOADING,
|
|
listLoading,
|
|
})
|
|
|
|
export const fetchObjects = () => {
|
|
return function (dispatch, getState) {
|
|
dispatch(resetList())
|
|
const {
|
|
buckets: { currentBucket },
|
|
objects: { currentPrefix },
|
|
} = getState()
|
|
if (currentBucket) {
|
|
dispatch(setListLoading(true))
|
|
return web
|
|
.ListObjects({
|
|
bucketName: currentBucket,
|
|
prefix: currentPrefix,
|
|
})
|
|
.then((res) => {
|
|
// we need to check if the bucket name and prefix are the same as
|
|
// when the request was made before updating the displayed objects
|
|
if (
|
|
currentBucket === getCurrentBucket(getState()) &&
|
|
currentPrefix === getCurrentPrefix(getState())
|
|
) {
|
|
let objects = []
|
|
if (res.objects) {
|
|
objects = res.objects.map((object) => {
|
|
return {
|
|
...object,
|
|
name: object.name.replace(currentPrefix, ""),
|
|
}
|
|
})
|
|
}
|
|
|
|
const sortBy = SORT_BY_LAST_MODIFIED
|
|
const sortOrder = SORT_ORDER_DESC
|
|
dispatch(setSortBy(sortBy))
|
|
dispatch(setSortOrder(sortOrder))
|
|
const sortedList = sortObjectsList(objects, sortBy, sortOrder)
|
|
dispatch(setList(sortedList))
|
|
|
|
dispatch(setPrefixWritable(res.writable))
|
|
dispatch(setListLoading(false))
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
if (web.LoggedIn()) {
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "danger",
|
|
message: err.message,
|
|
autoClear: true,
|
|
})
|
|
)
|
|
dispatch(resetList())
|
|
} else {
|
|
history.push("/login")
|
|
}
|
|
dispatch(setListLoading(false))
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
export const sortObjects = (sortBy) => {
|
|
return function (dispatch, getState) {
|
|
const { objects } = getState()
|
|
let sortOrder = SORT_ORDER_ASC
|
|
// Reverse sort order if the list is already sorted on same field
|
|
if (objects.sortBy === sortBy && objects.sortOrder === SORT_ORDER_ASC) {
|
|
sortOrder = SORT_ORDER_DESC
|
|
}
|
|
dispatch(setSortBy(sortBy))
|
|
dispatch(setSortOrder(sortOrder))
|
|
const sortedList = sortObjectsList(objects.list, sortBy, sortOrder)
|
|
dispatch(setList(sortedList))
|
|
}
|
|
}
|
|
|
|
const sortObjectsList = (list, sortBy, sortOrder) => {
|
|
switch (sortBy) {
|
|
case SORT_BY_NAME:
|
|
return sortObjectsByName(list, sortOrder)
|
|
case SORT_BY_SIZE:
|
|
return sortObjectsBySize(list, sortOrder)
|
|
case SORT_BY_LAST_MODIFIED:
|
|
return sortObjectsByDate(list, sortOrder)
|
|
}
|
|
}
|
|
|
|
export const setSortBy = (sortBy) => ({
|
|
type: SET_SORT_BY,
|
|
sortBy,
|
|
})
|
|
|
|
export const setSortOrder = (sortOrder) => ({
|
|
type: SET_SORT_ORDER,
|
|
sortOrder,
|
|
})
|
|
|
|
export const selectPrefix = (prefix) => {
|
|
return function (dispatch, getState) {
|
|
dispatch(setCurrentPrefix(prefix))
|
|
dispatch(fetchObjects())
|
|
dispatch(resetCheckedList())
|
|
const currentBucket = getCurrentBucket(getState())
|
|
history.replace(`/${currentBucket}/${prefix}`)
|
|
}
|
|
}
|
|
|
|
export const setCurrentPrefix = (prefix) => {
|
|
return {
|
|
type: SET_CURRENT_PREFIX,
|
|
prefix,
|
|
}
|
|
}
|
|
|
|
export const setPrefixWritable = (prefixWritable) => ({
|
|
type: SET_PREFIX_WRITABLE,
|
|
prefixWritable,
|
|
})
|
|
|
|
export const deleteObject = (object) => {
|
|
return function (dispatch, getState) {
|
|
const currentBucket = getCurrentBucket(getState())
|
|
const currentPrefix = getCurrentPrefix(getState())
|
|
const objectName = `${currentPrefix}${object}`
|
|
return web
|
|
.RemoveObject({
|
|
bucketName: currentBucket,
|
|
objects: [objectName],
|
|
})
|
|
.then(() => {
|
|
dispatch(removeObject(object))
|
|
})
|
|
.catch((e) => {
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "danger",
|
|
message: e.message,
|
|
})
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
export const removeObject = (object) => ({
|
|
type: REMOVE,
|
|
object,
|
|
})
|
|
|
|
export const deleteCheckedObjects = () => {
|
|
return function (dispatch, getState) {
|
|
const checkedObjects = getCheckedList(getState())
|
|
for (let i = 0; i < checkedObjects.length; i++) {
|
|
dispatch(deleteObject(checkedObjects[i]))
|
|
}
|
|
dispatch(resetCheckedList())
|
|
}
|
|
}
|
|
|
|
export const shareObject = (object, days, hours, minutes) => {
|
|
return function (dispatch, getState) {
|
|
const hasServerDomain = hasServerPublicDomain(getState())
|
|
const currentBucket = getCurrentBucket(getState())
|
|
const currentPrefix = getCurrentPrefix(getState())
|
|
const objectName = `${currentPrefix}${object}`
|
|
const expiry = days * 24 * 60 * 60 + hours * 60 * 60 + minutes * 60
|
|
if (web.LoggedIn()) {
|
|
return web
|
|
.GetBucketPolicy({ bucketName: currentBucket, prefix: currentPrefix })
|
|
.catch(() => ({ policy: null }))
|
|
.then(({ policy }) => {
|
|
if (hasServerDomain && ['readonly', 'readwrite'].includes(policy)) {
|
|
const domain = getServerInfo(getState()).info.domains[0]
|
|
const url = `${domain}/${currentBucket}/${encodeURI(objectName)}`
|
|
dispatch(showShareObject(object, url, false))
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "success",
|
|
message: "Object shared."
|
|
})
|
|
)
|
|
} else {
|
|
return web
|
|
.PresignedGet({
|
|
host: location.host,
|
|
bucket: currentBucket,
|
|
object: objectName,
|
|
expiry: expiry
|
|
})
|
|
}
|
|
})
|
|
.then((obj) => {
|
|
if (!obj) return
|
|
dispatch(showShareObject(object, obj.url))
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "success",
|
|
message: `Object shared. Expires in ${days} days ${hours} hours ${minutes} minutes`,
|
|
})
|
|
)
|
|
})
|
|
.catch((err) => {
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "danger",
|
|
message: err.message,
|
|
})
|
|
)
|
|
})
|
|
} else {
|
|
dispatch(
|
|
showShareObject(
|
|
object,
|
|
`${location.host}` +
|
|
"/" +
|
|
`${currentBucket}` +
|
|
"/" +
|
|
encodeURI(objectName)
|
|
)
|
|
)
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "success",
|
|
message: `Object shared.`,
|
|
})
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
export const showShareObject = (object, url, showExpiryDate = true) => ({
|
|
type: SET_SHARE_OBJECT,
|
|
show: true,
|
|
object,
|
|
url,
|
|
showExpiryDate,
|
|
})
|
|
|
|
export const hideShareObject = (object, url) => ({
|
|
type: SET_SHARE_OBJECT,
|
|
show: false,
|
|
object: "",
|
|
url: "",
|
|
})
|
|
export const getObjectURL = (object, callback) => {
|
|
return function (dispatch, getState) {
|
|
const currentBucket = getCurrentBucket(getState())
|
|
const currentPrefix = getCurrentPrefix(getState())
|
|
const objectName = `${currentPrefix}${object}`
|
|
const encObjectName = encodeURI(objectName)
|
|
if (web.LoggedIn()) {
|
|
return web
|
|
.CreateURLToken()
|
|
.then((res) => {
|
|
const url = `${window.location.origin}${minioBrowserPrefix}/download/${currentBucket}/${encObjectName}?token=${res.token}`
|
|
callback(url)
|
|
})
|
|
.catch((err) => {
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "danger",
|
|
message: err.message,
|
|
})
|
|
)
|
|
})
|
|
} else {
|
|
const url = `${window.location.origin}${minioBrowserPrefix}/download/${currentBucket}/${encObjectName}?token=`
|
|
callback(url)
|
|
}
|
|
}
|
|
}
|
|
export const downloadObject = (object) => {
|
|
return function (dispatch, getState) {
|
|
const currentBucket = getCurrentBucket(getState())
|
|
const currentPrefix = getCurrentPrefix(getState())
|
|
const objectName = `${currentPrefix}${object}`
|
|
const encObjectName = encodeURI(objectName)
|
|
if (web.LoggedIn()) {
|
|
return web
|
|
.CreateURLToken()
|
|
.then((res) => {
|
|
const url = `${window.location.origin}${minioBrowserPrefix}/download/${currentBucket}/${encObjectName}?token=${res.token}`
|
|
window.location = url
|
|
})
|
|
.catch((err) => {
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "danger",
|
|
message: err.message,
|
|
})
|
|
)
|
|
})
|
|
} else {
|
|
const url = `${window.location.origin}${minioBrowserPrefix}/download/${currentBucket}/${encObjectName}?token=`
|
|
window.location = url
|
|
}
|
|
}
|
|
}
|
|
|
|
export const downloadPrefix = (object) => {
|
|
return function (dispatch, getState) {
|
|
return downloadObjects(
|
|
getCurrentBucket(getState()),
|
|
getCurrentPrefix(getState()),
|
|
[object],
|
|
`${object.slice(0, -1)}.zip`,
|
|
dispatch
|
|
)
|
|
}
|
|
}
|
|
|
|
|
|
export const checkObject = (object) => ({
|
|
type: CHECKED_LIST_ADD,
|
|
object,
|
|
})
|
|
|
|
export const uncheckObject = (object) => ({
|
|
type: CHECKED_LIST_REMOVE,
|
|
object,
|
|
})
|
|
|
|
export const resetCheckedList = () => ({
|
|
type: CHECKED_LIST_RESET,
|
|
})
|
|
|
|
export const downloadCheckedObjects = () => {
|
|
return function (dispatch, getState) {
|
|
return downloadObjects(
|
|
getCurrentBucket(getState()),
|
|
getCurrentPrefix(getState()),
|
|
getCheckedList(getState()),
|
|
null,
|
|
dispatch
|
|
)
|
|
}
|
|
}
|
|
|
|
const downloadObjects = (bucketName, prefix, objects, filename, dispatch) => {
|
|
const req = {
|
|
bucketName: bucketName,
|
|
prefix: prefix,
|
|
objects: objects,
|
|
}
|
|
if (web.LoggedIn()) {
|
|
return web
|
|
.CreateURLToken()
|
|
.then((res) => {
|
|
const requestUrl = `${location.origin}${minioBrowserPrefix}/zip?token=${res.token}`
|
|
downloadZip(requestUrl, req, filename, dispatch)
|
|
})
|
|
.catch((err) =>
|
|
dispatch(
|
|
alertActions.set({
|
|
type: "danger",
|
|
message: err.message,
|
|
})
|
|
)
|
|
)
|
|
} else {
|
|
const requestUrl = `${location.origin}${minioBrowserPrefix}/zip?token=`
|
|
downloadZip(requestUrl, req, filename, dispatch)
|
|
}
|
|
}
|
|
|
|
const downloadZip = (url, req, filename, dispatch) => {
|
|
var anchor = document.createElement("a")
|
|
document.body.appendChild(anchor)
|
|
|
|
var xhr = new XMLHttpRequest()
|
|
xhr.open("POST", url, true)
|
|
xhr.responseType = "blob"
|
|
|
|
xhr.onload = function (e) {
|
|
if (this.status == 200) {
|
|
dispatch(resetCheckedList())
|
|
var blob = new Blob([this.response], {
|
|
type: "octet/stream",
|
|
})
|
|
var blobUrl = window.URL.createObjectURL(blob)
|
|
var separator = req.prefix.length > 1 ? "-" : ""
|
|
|
|
anchor.href = blobUrl
|
|
anchor.download = filename ||
|
|
req.bucketName + separator + req.prefix.slice(0, -1) + ".zip"
|
|
|
|
anchor.click()
|
|
window.URL.revokeObjectURL(blobUrl)
|
|
anchor.remove()
|
|
}
|
|
}
|
|
xhr.send(JSON.stringify(req))
|
|
}
|