Java Code Examples for java.nio.file.attribute.UserPrincipalLookupService

The following examples show how to use java.nio.file.attribute.UserPrincipalLookupService. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: jimfs   Source File: UserLookupServiceTest.java    License: Apache License 2.0 7 votes vote down vote up
@Test
public void testUserLookupService() throws IOException {
  UserPrincipalLookupService service = new UserLookupService(true);
  UserPrincipal bob1 = service.lookupPrincipalByName("bob");
  UserPrincipal bob2 = service.lookupPrincipalByName("bob");
  UserPrincipal alice = service.lookupPrincipalByName("alice");

  assertThat(bob1).isEqualTo(bob2);
  assertThat(bob1).isNotEqualTo(alice);

  GroupPrincipal group1 = service.lookupPrincipalByGroupName("group");
  GroupPrincipal group2 = service.lookupPrincipalByGroupName("group");
  GroupPrincipal foo = service.lookupPrincipalByGroupName("foo");

  assertThat(group1).isEqualTo(group2);
  assertThat(group1).isNotEqualTo(foo);
}
 
Example 2
/**
 * Make sure the {@literal actionchains} subdir exists.
 * @return the {@link Path} of the {@literal} actionchains directory
 */
private Path createActionChainsDir() {
    Path targetDir = getTargetDir();
    if (!Files.exists(targetDir)) {
        try {
            Files.createDirectories(targetDir);
            if (!skipSetOwner) {
                FileSystem fileSystem = FileSystems.getDefault();
                UserPrincipalLookupService service = fileSystem.getUserPrincipalLookupService();
                UserPrincipal tomcatUser = service.lookupPrincipalByName("tomcat");
                Files.setOwner(targetDir, tomcatUser);
            }
        }
        catch (IOException e) {
            LOG.error("Could not create action chain directory " + targetDir, e);
            throw new RuntimeException(e);
        }
    }
    return targetDir;
}
 
Example 3
/** This method changes the ownership of folder/file to the user provided
 * @param destinationLocation : the location of the path to be owned
 * @param user : the user which needs to own the folder/file
 */
private void changeOwnership(String destinationLocation, String user){
	
	Path path = Paths.get(destinationLocation);
    FileOwnerAttributeView view = Files.getFileAttributeView(path,
        FileOwnerAttributeView.class);
    UserPrincipalLookupService lookupService = FileSystems.getDefault()
        .getUserPrincipalLookupService();
    UserPrincipal userPrincipal;
	try {
		userPrincipal = lookupService.lookupPrincipalByName(user);
		Files.setOwner(path, userPrincipal);
	} catch (IOException e) {
		LOGGER.error("Error while changing ownership of destination location[" + destinationLocation +"]" + "to user[" + user + "]" , e);
	}
}
 
Example 4
Source Project: uyuni   Source File: SCCRefreshLock.java    License: GNU General Public License v2.0 5 votes vote down vote up
/**
 * tries to obtain the lock or throws an exception
 */
public static void tryGetLock() {
    try {
        f = new File(REFRESH_FILE_LOCKED_PATH);
        synchronized (f) {
            // create the lock file
            channel = new RandomAccessFile(f, "rw").getChannel();
            // create it with correct user
            FileSystem fileSystem = FileSystems.getDefault();
            UserPrincipalLookupService service = fileSystem.getUserPrincipalLookupService();
            UserPrincipal rootUser = service.lookupPrincipalByName("root");
            UserPrincipal tomcatUser = service.lookupPrincipalByName("tomcat");
            if (Files.getOwner(f.toPath(), LinkOption.NOFOLLOW_LINKS).equals(rootUser)) {
                Files.setOwner(f.toPath(), tomcatUser);
            }
            lock = channel.tryLock();
            if (lock == null) {
                // File is lock by other application
                channel.close();
                log.warn("SCC refresh is already running.");
                throw new OverlappingFileLockException();
            }
            log.info("Got the Lock for scc refresh");
            // Add on exit handler to release lock when application shutdown
            OnExitHandler onExitHandler = new OnExitHandler();
            Runtime.getRuntime().addShutdownHook(onExitHandler);
        }
    }
    catch (IOException e) {
        throw new RuntimeException("Could not start process.", e);
    }
}
 
Example 5
private void setFileOwner(Path path) throws IOException {
    FileSystem fileSystem = FileSystems.getDefault();
    UserPrincipalLookupService service = fileSystem.getUserPrincipalLookupService();
    UserPrincipal tomcatUser = service.lookupPrincipalByName("tomcat");

    Files.setOwner(path, tomcatUser);
}
 
Example 6
Source Project: vespa   Source File: UnixPath.java    License: Apache License 2.0 5 votes vote down vote up
public UnixPath setOwner(String owner) {
    UserPrincipalLookupService service = path.getFileSystem().getUserPrincipalLookupService();
    UserPrincipal principal = uncheck(
            () -> service.lookupPrincipalByName(owner),
            "While looking up user %s", owner);
    uncheck(() -> Files.setOwner(path, principal));
    return this;
}
 
Example 7
Source Project: vespa   Source File: UnixPath.java    License: Apache License 2.0 5 votes vote down vote up
public UnixPath setGroup(String group) {
    UserPrincipalLookupService service = path.getFileSystem().getUserPrincipalLookupService();
    GroupPrincipal principal = uncheck(
            () -> service.lookupPrincipalByGroupName(group),
            "while looking up group %s", group);
    uncheck(() -> Files.getFileAttributeView(path, PosixFileAttributeView.class).setGroup(principal));
    return this;
}
 
Example 8
Source Project: skUtilities   Source File: SExprFileOwner.java    License: GNU General Public License v3.0 5 votes vote down vote up
public void change(Event e, Object[] delta, Changer.ChangeMode mode) {
  if (mode == Changer.ChangeMode.SET) {
    Path pth = Paths.get(skUtilities.getDefaultPath(path.getSingle(e)));
    try {
      UserPrincipalLookupService lookupService = FileSystems.getDefault().getUserPrincipalLookupService();
      Files.setOwner(pth, lookupService.lookupPrincipalByName((String) delta[0]));
    } catch (Exception x) {
      skUtilities.prSysE("File: '" + pth + "' doesn't exist, or is not readable!", getClass().getSimpleName(), x);
    }
  }
}
 
Example 9
private UserPrincipal getUserPrincipalFrom(String userName) throws IOException
{
    try {
        if (_isCacheEnabled) {
            return _nameToUserPrincipal.get(userName);
        }
        UserPrincipalLookupService service =
                FileSystems.getDefault().getUserPrincipalLookupService();
        return service.lookupPrincipalByName(userName);
    } catch (IOException | UnsupportedOperationException e) {
        return null;
    }
}
 
Example 10
private GroupPrincipal getGroupPrincipalFrom(String groupName) throws IOException
{
    try {
        if (_isCacheEnabled) {
            return _nameToGroupPrincipal.get(groupName);
        }
        UserPrincipalLookupService service =
                FileSystems.getDefault().getUserPrincipalLookupService();
        return service.lookupPrincipalByGroupName(groupName);
    } catch (IOException | UnsupportedOperationException e) {
        return null;
    }
}
 
Example 11
private UserPrincipal getUserPrincipalFrom(String userName) throws IOException
{
    try {
        UserPrincipal principal = _nameToUserPrincipal.get(userName);
        if (principal == null) {
            UserPrincipalLookupService service =
                    FileSystems.getDefault().getUserPrincipalLookupService();
            principal = service.lookupPrincipalByName(userName);
            _nameToUserPrincipal.put(userName, principal);
        }
        return principal;
    } catch (UnsupportedOperationException e) {
        throw new IOException(e);
    }
}
 
Example 12
private GroupPrincipal getGroupPrincipalFrom(String groupName) throws IOException
{
    try {
        GroupPrincipal principal = _nameToGroupPrincipal.get(groupName);
        if (principal == null) {
            UserPrincipalLookupService service =
                    FileSystems.getDefault().getUserPrincipalLookupService();
            principal = service.lookupPrincipalByGroupName(groupName);
            _nameToGroupPrincipal.put(groupName, principal);
        }
        return principal;
    } catch (UnsupportedOperationException e) {
        throw new IOException(e);
    }
}
 
Example 13
@Override
public UserPrincipal getOwner() throws IOException {
  UserPrincipalLookupService ls = this.path.getFileSystem()
      .getUserPrincipalLookupService();
  FileStatus fileStatus = path.getFileSystem().getHDFS()
      .getFileStatus(path.getRawResolvedPath());
  return ls.lookupPrincipalByName(fileStatus.getOwner());
}
 
Example 14
/**
 * Test UserPrincipalLookupService support.
 * 
 * @throws IOException
 */
@Test
public void testGetPosixViewSetOwner() throws IOException {
  Path rootPath = Paths.get(clusterUri);

  UserPrincipalLookupService lus = rootPath.getFileSystem()
      .getUserPrincipalLookupService();
  assertNotNull(lus);
}
 
Example 15
Source Project: jimfs   Source File: UserLookupServiceTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testServiceNotSupportingGroups() throws IOException {
  UserPrincipalLookupService service = new UserLookupService(false);

  try {
    service.lookupPrincipalByGroupName("group");
    fail();
  } catch (UserPrincipalNotFoundException expected) {
    assertThat(expected.getName()).isEqualTo("group");
  }
}
 
Example 16
Source Project: logging-log4j2   Source File: FileUtils.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Define file posix attribute view on a path/file.
 *
 * @param path Target path
 * @param filePermissions Permissions to apply
 * @param fileOwner File owner
 * @param fileGroup File group
 * @throws IOException If IO error during definition of file attribute view
 */
public static void defineFilePosixAttributeView(final Path path,
        final Set<PosixFilePermission> filePermissions,
        final String fileOwner,
        final String fileGroup) throws IOException {
    final PosixFileAttributeView view = Files.getFileAttributeView(path, PosixFileAttributeView.class);
    if (view != null) {
        final UserPrincipalLookupService lookupService = FileSystems.getDefault()
                .getUserPrincipalLookupService();
        if (fileOwner != null) {
            final UserPrincipal userPrincipal = lookupService.lookupPrincipalByName(fileOwner);
            if (userPrincipal != null) {
                // If not sudoers member, it will throw Operation not permitted
                // Only processes with an effective user ID equal to the user ID
                // of the file or with appropriate privileges may change the ownership of a file.
                // If _POSIX_CHOWN_RESTRICTED is in effect for path
                view.setOwner(userPrincipal);
            }
        }
        if (fileGroup != null) {
            final GroupPrincipal groupPrincipal = lookupService.lookupPrincipalByGroupName(fileGroup);
            if (groupPrincipal != null) {
                // The current user id should be members of this group,
                // if not will raise Operation not permitted
                view.setGroup(groupPrincipal);
            }
        }
        if (filePermissions != null) {
            view.setPermissions(filePermissions);
        }
    }
}
 
Example 17
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 18
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 19
Source Project: uyuni   Source File: SaltService.java    License: GNU General Public License v2.0 4 votes vote down vote up
/**
 * {@inheritDoc}
 */
public Map<Boolean, String> storeMinionScapFiles(
        MinionServer minion, String uploadDir, Long actionId) {
    String actionPath = ScapFileManager
            .getActionPath(minion.getOrg().getId(),
                    minion.getId(), actionId);
    Path mountPoint = Paths.get(com.redhat.rhn.common.conf.Config.get()
            .getString(ConfigDefaults.MOUNT_POINT));
    try {
        // create dirs
        Path actionDir = Files.createDirectories(mountPoint.resolve(actionPath));

        UserPrincipalLookupService lookupService = FileSystems.getDefault()
                .getUserPrincipalLookupService();
        GroupPrincipal susemanagerGroup = lookupService
                .lookupPrincipalByGroupName("susemanager");
        GroupPrincipal wwwGroup = lookupService
                .lookupPrincipalByGroupName("www");
        // systems/<orgId>/<serverId>/actions/<actionId>
        changeGroupAndPerms(actionDir, susemanagerGroup);
        // systems/<orgId>/<serverId>/actions
        actionDir = actionDir.getParent();
        while (!actionDir.equals(mountPoint)) {
            changeGroupAndPerms(actionDir, wwwGroup);
            actionDir = actionDir.getParent();
        }

    }
    catch (IOException e) {
        LOG.error("Error creating dir " + mountPoint.resolve(actionPath), e);
    }

    RunnerCall<Map<Boolean, String>> call = MgrUtilRunner.moveMinionUploadedFiles(
            minion.getMinionId(),
            uploadDir,
            com.redhat.rhn.common.conf.Config.get()
                    .getString(ConfigDefaults.MOUNT_POINT),
            actionPath);
    Optional<Map<Boolean, String>> result = callSync(call,
            err -> err.fold(
                    e -> {
                        LOG.error("Function [" + e.getFunctionName() +
                                " not available for runner call " +
                                "[mgrutil.move_minion_uploaded_files].");
                        return Optional.of(Collections.singletonMap(false,
                                "Function [" + e.getFunctionName()));
                    },
                    e -> {
                        LOG.error("Module [" + e.getModuleName() +
                                "] not supported for runner call " +
                                "[mgrutil.move_minion_uploaded_files].");
                        return Optional.of(Collections.singletonMap(false,
                                "Module [" + e.getModuleName() + "] not supported"));
                    },
                    e -> {
                        LOG.error("Error parsing json response from " +
                                "runner call [mgrutil.move_minion_uploaded_files]: " +
                                e.getJson());
                        return Optional.of(Collections.singletonMap(false,
                                "Error parsing json response: " + e.getJson()));
                    },
                    e -> {
                        LOG.error("Generic Salt error for runner call " +
                                "[mgrutil.move_minion_uploaded_files]: " +
                                e.getMessage());
                        return Optional.of(Collections.singletonMap(false,
                                "Generic Salt error: " + e.getMessage()));
                    }
            )
    );
    return result.orElseGet(() ->
            Collections.singletonMap(false, "Error moving scap result files." +
                    " Please check the logs.")
    );
}
 
Example 20
Source Project: jdk8u60   Source File: FaultyFileSystem.java    License: GNU General Public License v2.0 4 votes vote down vote up
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 21
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 22
Source Project: openjdk-systemtest   Source File: MemoryFileSystem.java    License: Apache License 2.0 4 votes vote down vote up
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
	return null;
}
 
Example 23
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 24
Source Project: Bytecoder   Source File: JrtFileSystem.java    License: Apache License 2.0 4 votes vote down vote up
@Override
public final UserPrincipalLookupService getUserPrincipalLookupService() {
    throw new UnsupportedOperationException();
}
 
Example 25
Source Project: openjdk-jdk9   Source File: JrtFileSystem.java    License: GNU General Public License v2.0 4 votes vote down vote up
@Override
public final UserPrincipalLookupService getUserPrincipalLookupService() {
    throw new UnsupportedOperationException();
}
 
Example 26
Source Project: openjdk-jdk9   Source File: TestProvider.java    License: GNU General Public License v2.0 4 votes vote down vote up
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    return delegate.getUserPrincipalLookupService();
}
 
Example 27
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 28
Source Project: jdk8u-jdk   Source File: FaultyFileSystem.java    License: GNU General Public License v2.0 4 votes vote down vote up
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 29
Source Project: hottub   Source File: FaultyFileSystem.java    License: GNU General Public License v2.0 4 votes vote down vote up
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}
 
Example 30
@Override
public UserPrincipalLookupService getUserPrincipalLookupService() {
    // assume that unwrapped objects aren't exposed
    return delegate.getUserPrincipalLookupService();
}