/// <summary> /// Returns a <seealso cref="Callable"/> object that, when /// called, runs the given privileged exception action and returns /// its result. </summary> /// <param name="action"> the privileged exception action to run </param> /// <returns> a callable object </returns> /// <exception cref="NullPointerException"> if action null </exception> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not allowed in .NET: //ORIGINAL LINE: public static Callable<Object> callable(final java.security.PrivilegedExceptionAction<?> action) public static Callable <Object> Callable(PrivilegedExceptionAction <T1> action) { if (action == null) { throw new NullPointerException(); } return(new CallableAnonymousInnerClassHelper2(action)); }
/// <exception cref="System.IO.IOException"/> /// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> private object OperateDelegationToken <_T0>(PrivilegedExceptionAction <_T0> action) { // Set up the retry operation TimelineClientImpl.TimelineClientRetryOp tokenRetryOp = new _TimelineClientRetryOp_444 (this, action); // Try pass the request, if fail, keep retrying // Only retry on connection exceptions return(connectionRetry.RetryOn(tokenRetryOp)); }
public static object doPrivileged(Type accessController, PrivilegedExceptionAction action) { try { return(action.run()); } catch (global::java.lang.Exception ex) { throw new PrivilegedActionException(ex); } }
/// <summary> /// Performs the specified {@code PrivilegedExceptionAction} with /// privileges enabled and restricted by the specified /// {@code AccessControlContext} and with a privilege scope limited by /// specified {@code Permission} arguments. /// /// The action is performed with the intersection of the permissions /// possessed by the caller's protection domain, and those possessed /// by the domains represented by the specified /// {@code AccessControlContext}. /// <para> /// If the action's {@code run} method throws an (unchecked) exception, /// it will propagate through this method. /// </para> /// <para> /// If a security manager is installed and the specified /// {@code AccessControlContext} was not created by system code and the /// caller's {@code ProtectionDomain} has not been granted the /// {@literal "createAccessControlContext"} /// <seealso cref="java.security.SecurityPermission"/>, then the action is performed /// with no permissions. /// /// </para> /// </summary> /// @param <T> the type of the value returned by the /// PrivilegedExceptionAction's {@code run} method. </param> /// <param name="action"> the action to be performed. </param> /// <param name="context"> an <i>access control context</i> /// representing the restriction to be applied to the /// caller's domain's privileges before performing /// the specified action. If the context is /// {@code null}, /// then no additional restriction is applied. </param> /// <param name="perms"> the {@code Permission} arguments which limit the /// scope of the caller's privileges. The number of arguments /// is variable. /// </param> /// <returns> the value returned by the action's {@code run} method. /// </returns> /// <exception cref="PrivilegedActionException"> if the specified action's /// {@code run} method threw a <i>checked</i> exception </exception> /// <exception cref="NullPointerException"> if action or perms or any element of /// perms is {@code null} /// </exception> /// <seealso cref= #doPrivileged(PrivilegedAction) </seealso> /// <seealso cref= #doPrivileged(PrivilegedAction,AccessControlContext) /// /// @since 1.8 </seealso> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @CallerSensitive public static <T> T doPrivileged(PrivilegedExceptionAction<T> action, AccessControlContext context, Permission... perms) throws PrivilegedActionException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public static T doPrivileged <T>(PrivilegedExceptionAction <T> action, AccessControlContext context, params Permission[] perms) { AccessControlContext parent = Context; if (perms == null) { throw new NullPointerException("null permissions parameter"); } Class caller = Reflection.CallerClass; return(AccessController.doPrivileged(action, CreateWrapper(null, caller, parent, context, perms))); }
/// <summary> /// Performs the specified {@code PrivilegedExceptionAction} with /// privileges enabled. The action is performed with <i>all</i> of the /// permissions possessed by the caller's protection domain. /// /// <para> If the action's {@code run} method throws an <i>unchecked</i> /// exception, it will propagate through this method. /// /// </para> /// <para> This method preserves the current AccessControlContext's /// DomainCombiner (which may be null) while the action is performed. /// /// </para> /// </summary> /// @param <T> the type of the value returned by the /// PrivilegedExceptionAction's {@code run} method. /// </param> /// <param name="action"> the action to be performed. /// </param> /// <returns> the value returned by the action's {@code run} method /// </returns> /// <exception cref="PrivilegedActionException"> if the specified action's /// {@code run} method threw a <i>checked</i> exception </exception> /// <exception cref="NullPointerException"> if the action is {@code null} /// </exception> /// <seealso cref= #doPrivileged(PrivilegedAction) </seealso> /// <seealso cref= #doPrivileged(PrivilegedExceptionAction,AccessControlContext) </seealso> /// <seealso cref= java.security.DomainCombiner /// /// @since 1.6 </seealso> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @CallerSensitive public static <T> T doPrivilegedWithCombiner(PrivilegedExceptionAction<T> action) throws PrivilegedActionException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public static T doPrivilegedWithCombiner <T>(PrivilegedExceptionAction <T> action) { AccessControlContext acc = StackAccessControlContext; if (acc == null) { return(AccessController.doPrivileged(action)); } DomainCombiner dc = acc.AssignedCombiner; return(AccessController.doPrivileged(action, PreserveCombiner(dc, Reflection.CallerClass))); }
/// <exception cref="System.IO.IOException"/> private static T DoAsUser <T>(UserGroupInformation ugi, PrivilegedExceptionAction < T> action) { try { return(ugi.DoAs(action)); } catch (Exception ie) { throw new IOException(ie); } }
private void ShouldThrow(PrivilegedExceptionAction <object> action, Type except) { try { action.Run(); NUnit.Framework.Assert.Fail("action did not throw " + except); } catch (Exception th) { Log.Info("Caught an exception: ", th); Assert.Equal("action threw wrong exception", except, th.GetType ()); } }
/// <summary> /// Performs the specified {@code PrivilegedExceptionAction} with /// privileges enabled and restricted by the specified /// {@code AccessControlContext} and with a privilege scope limited by /// specified {@code Permission} arguments. /// /// The action is performed with the intersection of the permissions /// possessed by the caller's protection domain, and those possessed /// by the domains represented by the specified /// {@code AccessControlContext}. /// <para> /// If the action's {@code run} method throws an (unchecked) exception, /// it will propagate through this method. /// /// </para> /// <para> This method preserves the current AccessControlContext's /// DomainCombiner (which may be null) while the action is performed. /// </para> /// <para> /// If a security manager is installed and the specified /// {@code AccessControlContext} was not created by system code and the /// caller's {@code ProtectionDomain} has not been granted the /// {@literal "createAccessControlContext"} /// <seealso cref="java.security.SecurityPermission"/>, then the action is performed /// with no permissions. /// /// </para> /// </summary> /// @param <T> the type of the value returned by the /// PrivilegedExceptionAction's {@code run} method. </param> /// <param name="action"> the action to be performed. </param> /// <param name="context"> an <i>access control context</i> /// representing the restriction to be applied to the /// caller's domain's privileges before performing /// the specified action. If the context is /// {@code null}, /// then no additional restriction is applied. </param> /// <param name="perms"> the {@code Permission} arguments which limit the /// scope of the caller's privileges. The number of arguments /// is variable. /// </param> /// <returns> the value returned by the action's {@code run} method. /// </returns> /// <exception cref="PrivilegedActionException"> if the specified action's /// {@code run} method threw a <i>checked</i> exception </exception> /// <exception cref="NullPointerException"> if action or perms or any element of /// perms is {@code null} /// </exception> /// <seealso cref= #doPrivileged(PrivilegedAction) </seealso> /// <seealso cref= #doPrivileged(PrivilegedAction,AccessControlContext) </seealso> /// <seealso cref= java.security.DomainCombiner /// /// @since 1.8 </seealso> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @CallerSensitive public static <T> T doPrivilegedWithCombiner(PrivilegedExceptionAction<T> action, AccessControlContext context, Permission... perms) throws PrivilegedActionException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public static T doPrivilegedWithCombiner <T>(PrivilegedExceptionAction <T> action, AccessControlContext context, params Permission[] perms) { AccessControlContext parent = Context; DomainCombiner dc = parent.Combiner; if (dc == null && context != null) { dc = context.Combiner; } if (perms == null) { throw new NullPointerException("null permissions parameter"); } Class caller = Reflection.CallerClass; return(AccessController.doPrivileged(action, CreateWrapper(dc, caller, parent, context, perms))); }
public CallableAnonymousInnerClassHelper2(PrivilegedExceptionAction <T1> action) { this.Action = action; }
public static extern <T> T doPrivileged(PrivilegedExceptionAction <T> action, AccessControlContext context);
public static extern <T> T doPrivileged(PrivilegedExceptionAction <T> action);
public _TimelineClientRetryOp_444(TimelineClientImpl _enclosing, PrivilegedExceptionAction <object> action) { this._enclosing = _enclosing; this.action = action; }
/// <summary>Perform the given action as the daemon's current user.</summary> /// <remarks> /// Perform the given action as the daemon's current user. If an /// InterruptedException is thrown, it is converted to an IOException. /// </remarks> /// <param name="action">the action to perform</param> /// <returns>the result of the action</returns> /// <exception cref="System.IO.IOException">in the event of error</exception> public static T DoAsCurrentUser <T>(PrivilegedExceptionAction <T> action) { return(DoAsUser(UserGroupInformation.GetCurrentUser(), action)); }
public static object doPrivileged(Type accessController, PrivilegedExceptionAction action, AccessControlContext context) { return(doPrivileged(accessController, action)); }