use of alluxio.exception.AccessControlException in project alluxio by Alluxio.
the class AlluxioMasterRestServiceHandler method getWebUIBrowse.
/**
* Gets Web UI browse page data.
*
* @param requestPath the request path
* @param requestOffset the request offset
* @param requestEnd the request end
* @param requestLimit the request limit
* @return the response object
*/
@GET
@Path(WEBUI_BROWSE)
public Response getWebUIBrowse(@DefaultValue("/") @QueryParam("path") String requestPath, @DefaultValue("0") @QueryParam("offset") String requestOffset, @DefaultValue("") @QueryParam("end") String requestEnd, @DefaultValue("20") @QueryParam("limit") String requestLimit) {
return RestUtils.call(() -> {
MasterWebUIBrowse response = new MasterWebUIBrowse();
if (!ServerConfiguration.getBoolean(PropertyKey.WEB_FILE_INFO_ENABLED)) {
return response;
}
if (SecurityUtils.isSecurityEnabled(ServerConfiguration.global()) && AuthenticatedClientUser.get(ServerConfiguration.global()) == null) {
AuthenticatedClientUser.set(ServerUserState.global().getUser().getName());
}
response.setDebug(ServerConfiguration.getBoolean(PropertyKey.DEBUG)).setShowPermissions(ServerConfiguration.getBoolean(PropertyKey.SECURITY_AUTHORIZATION_PERMISSION_ENABLED)).setMasterNodeAddress(mMasterProcess.getRpcAddress().toString()).setInvalidPathError("");
List<FileInfo> filesInfo;
String path = URLDecoder.decode(requestPath, "UTF-8");
if (path.isEmpty()) {
path = AlluxioURI.SEPARATOR;
}
AlluxioURI currentPath = new AlluxioURI(path);
response.setCurrentPath(currentPath.toString()).setViewingOffset(0);
try {
long fileId = mFileSystemMaster.getFileId(currentPath);
FileInfo fileInfo = mFileSystemMaster.getFileInfo(fileId);
UIFileInfo currentFileInfo = new UIFileInfo(fileInfo, ServerConfiguration.global(), new MasterStorageTierAssoc().getOrderedStorageAliases());
if (currentFileInfo.getAbsolutePath() == null) {
throw new FileDoesNotExistException(currentPath.toString());
}
response.setCurrentDirectory(currentFileInfo).setBlockSizeBytes(currentFileInfo.getBlockSizeBytes());
if (!currentFileInfo.getIsDirectory()) {
long relativeOffset = 0;
long offset;
try {
if (requestOffset != null) {
relativeOffset = Long.parseLong(requestOffset);
}
} catch (NumberFormatException e) {
// ignore the exception
}
// relative to the end of the file.
if (requestEnd.equals("")) {
offset = relativeOffset;
} else {
offset = fileInfo.getLength() - relativeOffset;
}
if (offset < 0) {
offset = 0;
} else if (offset > fileInfo.getLength()) {
offset = fileInfo.getLength();
}
try {
AlluxioURI absolutePath = new AlluxioURI(currentFileInfo.getAbsolutePath());
FileSystem fs = mFsClient;
String fileData;
URIStatus status = fs.getStatus(absolutePath);
if (status.isCompleted()) {
OpenFilePOptions options = OpenFilePOptions.newBuilder().setReadType(ReadPType.NO_CACHE).build();
try (FileInStream is = fs.openFile(absolutePath, options)) {
int len = (int) Math.min(5L * Constants.KB, status.getLength() - offset);
byte[] data = new byte[len];
long skipped = is.skip(offset);
if (skipped < 0) {
// nothing was skipped
fileData = "Unable to traverse to offset; is file empty?";
} else if (skipped < offset) {
// couldn't skip all the way to offset
fileData = "Unable to traverse to offset; is offset larger than the file?";
} else {
// read may not read up to len, so only convert what was read
int read = is.read(data, 0, len);
if (read < 0) {
// stream couldn't read anything, skip went to EOF?
fileData = "Unable to read file";
} else {
fileData = WebUtils.convertByteArrayToStringWithoutEscape(data, 0, read);
}
}
}
} else {
fileData = "The requested file is not complete yet.";
}
List<UIFileBlockInfo> uiBlockInfo = new ArrayList<>();
for (FileBlockInfo fileBlockInfo : mFileSystemMaster.getFileBlockInfoList(absolutePath)) {
uiBlockInfo.add(new UIFileBlockInfo(fileBlockInfo, ServerConfiguration.global()));
}
response.setFileBlocks(uiBlockInfo).setFileData(fileData).setHighestTierAlias(mBlockMaster.getGlobalStorageTierAssoc().getAlias(0));
} catch (AlluxioException e) {
throw new IOException(e);
}
response.setViewingOffset(offset);
return response;
}
if (currentPath.isRoot()) {
response.setPathInfos(new UIFileInfo[0]);
} else {
String[] splitPath = PathUtils.getPathComponents(currentPath.toString());
UIFileInfo[] pathInfos = new UIFileInfo[splitPath.length - 1];
fileId = mFileSystemMaster.getFileId(currentPath);
pathInfos[0] = new UIFileInfo(mFileSystemMaster.getFileInfo(fileId), ServerConfiguration.global(), new MasterStorageTierAssoc().getOrderedStorageAliases());
AlluxioURI breadcrumb = new AlluxioURI(AlluxioURI.SEPARATOR);
for (int i = 1; i < splitPath.length - 1; i++) {
breadcrumb = breadcrumb.join(splitPath[i]);
fileId = mFileSystemMaster.getFileId(breadcrumb);
pathInfos[i] = new UIFileInfo(mFileSystemMaster.getFileInfo(fileId), ServerConfiguration.global(), new MasterStorageTierAssoc().getOrderedStorageAliases());
}
response.setPathInfos(pathInfos);
}
filesInfo = mFileSystemMaster.listStatus(currentPath, ListStatusContext.defaults());
} catch (FileDoesNotExistException e) {
response.setInvalidPathError("Error: Invalid Path " + e.getMessage());
return response;
} catch (InvalidPathException e) {
response.setInvalidPathError("Error: Invalid Path " + e.getLocalizedMessage());
return response;
} catch (UnavailableException e) {
response.setInvalidPathError("The service is temporarily unavailable. " + e.getMessage());
return response;
} catch (IOException e) {
response.setInvalidPathError("Error: File " + currentPath + " is not available " + e.getMessage());
return response;
} catch (AccessControlException e) {
response.setInvalidPathError("Error: File " + currentPath + " cannot be accessed " + e.getMessage());
return response;
}
List<UIFileInfo> fileInfos = new ArrayList<>(filesInfo.size());
for (FileInfo fileInfo : filesInfo) {
UIFileInfo toAdd = new UIFileInfo(fileInfo, ServerConfiguration.global(), new MasterStorageTierAssoc().getOrderedStorageAliases());
try {
if (!toAdd.getIsDirectory() && fileInfo.getLength() > 0) {
FileBlockInfo blockInfo = mFileSystemMaster.getFileBlockInfoList(new AlluxioURI(toAdd.getAbsolutePath())).get(0);
List<String> locations = new ArrayList<>();
// add the in-Alluxio block locations
for (BlockLocation location : blockInfo.getBlockInfo().getLocations()) {
WorkerNetAddress address = location.getWorkerAddress();
locations.add(address.getHost() + ":" + address.getDataPort());
}
// add underFS locations
locations.addAll(blockInfo.getUfsLocations());
toAdd.setFileLocations(locations);
}
} catch (FileDoesNotExistException e) {
response.setFileDoesNotExistException("Error: non-existing file " + e.getMessage());
return response;
} catch (InvalidPathException e) {
response.setInvalidPathException("Error: invalid path " + e.getMessage());
return response;
} catch (AccessControlException e) {
response.setAccessControlException("Error: File " + currentPath + " cannot be accessed " + e.getMessage());
return response;
}
fileInfos.add(toAdd);
}
fileInfos.sort(UIFileInfo.PATH_STRING_COMPARE);
response.setNTotalFile(fileInfos.size());
try {
int offset = Integer.parseInt(requestOffset);
int limit = Integer.parseInt(requestLimit);
limit = offset == 0 && limit > fileInfos.size() ? fileInfos.size() : limit;
limit = offset + limit > fileInfos.size() ? fileInfos.size() - offset : limit;
int sum = Math.addExact(offset, limit);
fileInfos = fileInfos.subList(offset, sum);
response.setFileInfos(fileInfos);
} catch (NumberFormatException e) {
response.setFatalError("Error: offset or limit parse error, " + e.getLocalizedMessage());
return response;
} catch (ArithmeticException e) {
response.setFatalError("Error: offset or offset + limit is out of bound, " + e.getLocalizedMessage());
return response;
} catch (IllegalArgumentException e) {
response.setFatalError(e.getLocalizedMessage());
return response;
}
return response;
}, ServerConfiguration.global());
}
use of alluxio.exception.AccessControlException in project alluxio by Alluxio.
the class AlluxioJniFuseFileSystem method getattrInternal.
private int getattrInternal(String path, FileStat stat) {
final AlluxioURI uri = mPathResolverCache.getUnchecked(path);
try {
URIStatus status = null;
// Handle special metadata cache operation
if (mConf.getBoolean(PropertyKey.FUSE_SPECIAL_COMMAND_ENABLED) && mFuseShell.isSpecialCommand(uri)) {
// TODO(lu) add cache for isFuseSpecialCommand if needed
status = mFuseShell.runCommand(uri);
} else {
status = mFileSystem.getStatus(uri);
}
long size = status.getLength();
if (!status.isCompleted()) {
if (mCreateFileEntries.contains(PATH_INDEX, path)) {
// Alluxio master will not update file length until file is completed
// get file length from the current output stream
CreateFileEntry<FileOutStream> ce = mCreateFileEntries.getFirstByField(PATH_INDEX, path);
if (ce != null) {
FileOutStream os = ce.getOut();
size = os.getBytesWritten();
}
} else if (!AlluxioFuseUtils.waitForFileCompleted(mFileSystem, uri)) {
// Always block waiting for file to be completed except when the file is writing
// We do not want to block the writing process
LOG.error("File {} is not completed", path);
} else {
// Update the file status after waiting
status = mFileSystem.getStatus(uri);
size = status.getLength();
}
}
stat.st_size.set(size);
// Sets block number to fulfill du command needs
// `st_blksize` is ignored in `getattr` according to
// https://github.com/libfuse/libfuse/blob/d4a7ba44b022e3b63fc215374d87ed9e930d9974/include/fuse.h#L302
// According to http://man7.org/linux/man-pages/man2/stat.2.html,
// `st_blocks` is the number of 512B blocks allocated
stat.st_blocks.set((int) Math.ceil((double) size / 512));
final long ctime_sec = status.getLastModificationTimeMs() / 1000;
final long atime_sec = status.getLastAccessTimeMs() / 1000;
// Keeps only the "residual" nanoseconds not caputred in citme_sec
final long ctime_nsec = (status.getLastModificationTimeMs() % 1000) * 1_000_000L;
final long atime_nsec = (status.getLastAccessTimeMs() % 1000) * 1_000_000L;
stat.st_atim.tv_sec.set(atime_sec);
stat.st_atim.tv_nsec.set(atime_nsec);
stat.st_ctim.tv_sec.set(ctime_sec);
stat.st_ctim.tv_nsec.set(ctime_nsec);
stat.st_mtim.tv_sec.set(ctime_sec);
stat.st_mtim.tv_nsec.set(ctime_nsec);
if (mIsUserGroupTranslation) {
// Translate the file owner/group to unix uid/gid
// Show as uid==-1 (nobody) if owner does not exist in unix
// Show as gid==-1 (nogroup) if group does not exist in unix
stat.st_uid.set(mUidCache.get(status.getOwner()));
stat.st_gid.set(mGidCache.get(status.getGroup()));
} else {
stat.st_uid.set(AlluxioFuseUtils.DEFAULT_UID);
stat.st_gid.set(AlluxioFuseUtils.DEFAULT_GID);
}
int mode = status.getMode();
if (status.isFolder()) {
mode |= FileStat.S_IFDIR;
} else {
mode |= FileStat.S_IFREG;
}
stat.st_mode.set(mode);
stat.st_nlink.set(1);
} catch (FileDoesNotExistException | InvalidPathException e) {
LOG.debug("Failed to get info of {}, path does not exist or is invalid", path);
return -ErrorCodes.ENOENT();
} catch (AccessControlException e) {
LOG.error("Permission denied when getattr {}: ", path, e);
return -ErrorCodes.EACCES();
} catch (Throwable e) {
LOG.error("Failed to getattr {}: ", path, e);
return -ErrorCodes.EIO();
}
return 0;
}
use of alluxio.exception.AccessControlException in project alluxio by Alluxio.
the class ReadOnlyMountIntegrationTest method chown.
@Test
public void chown() throws IOException, AlluxioException {
AlluxioURI uri = new AlluxioURI(FILE_PATH + "_chown");
try {
mFileSystem.setAttribute(uri, SetAttributePOptions.newBuilder().setOwner("foo").build());
Assert.fail("chown should not succeed under a readonly mount.");
} catch (AccessControlException e) {
Assert.assertThat(e.getMessage(), containsString(ExceptionMessage.MOUNT_READONLY.getMessage(uri, MOUNT_PATH)));
}
}
use of alluxio.exception.AccessControlException in project alluxio by Alluxio.
the class ReadOnlyMountIntegrationTest method renameFileSrc.
@Test
public void renameFileSrc() throws IOException, AlluxioException {
AlluxioURI srcUri = new AlluxioURI(FILE_PATH);
AlluxioURI dstUri = new AlluxioURI("/tmp");
try {
mFileSystem.rename(srcUri, dstUri);
Assert.fail("rename should not succeed under a readonly mount.");
} catch (AccessControlException e) {
Assert.assertThat(e.getMessage(), containsString(ExceptionMessage.MOUNT_READONLY.getMessage(srcUri, MOUNT_PATH)));
}
srcUri = new AlluxioURI(SUB_FILE_PATH);
try {
mFileSystem.rename(srcUri, dstUri);
Assert.fail("rename should not succeed under a readonly mount.");
} catch (AccessControlException e) {
Assert.assertThat(e.getMessage(), containsString(ExceptionMessage.MOUNT_READONLY.getMessage(srcUri, MOUNT_PATH)));
}
}
use of alluxio.exception.AccessControlException in project alluxio by Alluxio.
the class ReadOnlyMountIntegrationTest method renameDirectory.
@Test
public void renameDirectory() throws IOException, AlluxioException {
AlluxioURI srcUri = new AlluxioURI(SUB_DIR_PATH);
AlluxioURI dstUri = new AlluxioURI(SUB_DIR_PATH + "_renamed");
try {
mFileSystem.rename(srcUri, dstUri);
Assert.fail("renameDirectory should not succeed under a readonly mount.");
} catch (AccessControlException e) {
Assert.assertThat(e.getMessage(), containsString(ExceptionMessage.MOUNT_READONLY.getMessage(srcUri, MOUNT_PATH)));
}
}
Aggregations