/// <exception cref="Javax.Servlet.ServletException"/>
/// <exception cref="System.IO.IOException"/>
protected override void DoGet(HttpServletRequest request, HttpServletResponse response
)
{
string path = ServletUtil.GetDecodedPath(request, "/streamFile");
string rawPath = ServletUtil.GetRawPath(request, "/streamFile");
string filename = JspHelper.ValidatePath(path);
string rawFilename = JspHelper.ValidatePath(rawPath);
if (filename == null)
{
response.SetContentType("text/plain");
PrintWriter @out = response.GetWriter();
@out.Write("Invalid input");
return;
}
Enumeration <string> reqRanges = request.GetHeaders("Range");
if (reqRanges != null && !reqRanges.MoveNext())
{
reqRanges = null;
}
DFSClient dfs;
try
{
dfs = GetDFSClient(request);
}
catch (Exception e)
{
response.SendError(400, e.Message);
return;
}
HdfsDataInputStream @in = null;
OutputStream out_1 = null;
try
{
@in = dfs.CreateWrappedInputStream(dfs.Open(filename));
out_1 = response.GetOutputStream();
long fileLen = @in.GetVisibleLength();
if (reqRanges != null)
{
IList <InclusiveByteRange> ranges = InclusiveByteRange.SatisfiableRanges(reqRanges
, fileLen);
StreamFile.SendPartialData(@in, out_1, response, fileLen, ranges);
}
else
{
// No ranges, so send entire file
response.SetHeader("Content-Disposition", "attachment; filename=\"" + rawFilename
+ "\"");
response.SetContentType("application/octet-stream");
response.SetHeader(ContentLength, string.Empty + fileLen);
StreamFile.CopyFromOffset(@in, out_1, 0L, fileLen);
}
@in.Close();
@in = null;
out_1.Close();
out_1 = null;
dfs.Close();
dfs = null;
}
catch (IOException ioe)
{
if (Log.IsDebugEnabled())
{
Log.Debug("response.isCommitted()=" + response.IsCommitted(), ioe);
}
throw;
}
finally
{
IOUtils.Cleanup(Log, @in);
IOUtils.Cleanup(Log, out_1);
IOUtils.Cleanup(Log, dfs);
}
}
/// <summary>
/// If the request has a valid authentication token it allows the request to continue to the target resource,
/// otherwise it triggers an authentication sequence using the configured
/// <see cref="AuthenticationHandler"/>
/// .
/// </summary>
/// <param name="request">the request object.</param>
/// <param name="response">the response object.</param>
/// <param name="filterChain">the filter chain object.</param>
/// <exception cref="System.IO.IOException">thrown if an IO error occurred.</exception>
/// <exception cref="Javax.Servlet.ServletException">thrown if a processing error occurred.
/// </exception>
public virtual void DoFilter(ServletRequest request, ServletResponse response, FilterChain
filterChain)
{
bool unauthorizedResponse = true;
int errCode = HttpServletResponse.ScUnauthorized;
AuthenticationException authenticationEx = null;
HttpServletRequest httpRequest = (HttpServletRequest)request;
HttpServletResponse httpResponse = (HttpServletResponse)response;
bool isHttps = "https".Equals(httpRequest.GetScheme());
try
{
bool newToken = false;
AuthenticationToken token;
try
{
token = GetToken(httpRequest);
}
catch (AuthenticationException ex)
{
Log.Warn("AuthenticationToken ignored: " + ex.Message);
// will be sent back in a 401 unless filter authenticates
authenticationEx = ex;
token = null;
}
if (authHandler.ManagementOperation(token, httpRequest, httpResponse))
{
if (token == null)
{
if (Log.IsDebugEnabled())
{
Log.Debug("Request [{}] triggering authentication", GetRequestURL(httpRequest));
}
token = authHandler.Authenticate(httpRequest, httpResponse);
if (token != null && token.GetExpires() != 0 && token != AuthenticationToken.Anonymous)
{
token.SetExpires(Runtime.CurrentTimeMillis() + GetValidity() * 1000);
}
newToken = true;
}
if (token != null)
{
unauthorizedResponse = false;
if (Log.IsDebugEnabled())
{
Log.Debug("Request [{}] user [{}] authenticated", GetRequestURL(httpRequest), token
.GetUserName());
}
AuthenticationToken authToken = token;
httpRequest = new _HttpServletRequestWrapper_532(authToken, httpRequest);
if (newToken && !token.IsExpired() && token != AuthenticationToken.Anonymous)
{
string signedToken = signer.Sign(token.ToString());
CreateAuthCookie(httpResponse, signedToken, GetCookieDomain(), GetCookiePath(), token
.GetExpires(), isHttps);
}
DoFilter(filterChain, httpRequest, httpResponse);
}
}
else
{
unauthorizedResponse = false;
}
}
catch (AuthenticationException ex)
{
// exception from the filter itself is fatal
errCode = HttpServletResponse.ScForbidden;
authenticationEx = ex;
if (Log.IsDebugEnabled())
{
Log.Debug("Authentication exception: " + ex.Message, ex);
}
else
{
Log.Warn("Authentication exception: " + ex.Message);
}
}
if (unauthorizedResponse)
{
if (!httpResponse.IsCommitted())
{
CreateAuthCookie(httpResponse, string.Empty, GetCookieDomain(), GetCookiePath(),
0, isHttps);
// If response code is 401. Then WWW-Authenticate Header should be
// present.. reset to 403 if not found..
if ((errCode == HttpServletResponse.ScUnauthorized) && (!httpResponse.ContainsHeader
(KerberosAuthenticator.WwwAuthenticate)))
{
errCode = HttpServletResponse.ScForbidden;
}
if (authenticationEx == null)
{
httpResponse.SendError(errCode, "Authentication required");
}
else
{
httpResponse.SendError(errCode, authenticationEx.Message);
}
}
}
}