/// <exception cref="System.IO.IOException"/>
private static void ConfigureSuperUserIPAddresses(Configuration conf, string superUserShortName
)
{
AList <string> ipList = new AList <string>();
Enumeration <NetworkInterface> netInterfaceList = NetworkInterface.GetNetworkInterfaces
();
while (netInterfaceList.MoveNext())
{
NetworkInterface inf = netInterfaceList.Current;
Enumeration <IPAddress> addrList = inf.GetInetAddresses();
while (addrList.MoveNext())
{
IPAddress addr = addrList.Current;
ipList.AddItem(addr.GetHostAddress());
}
}
StringBuilder builder = new StringBuilder();
foreach (string ip in ipList)
{
builder.Append(ip);
builder.Append(',');
}
builder.Append("127.0.1.1,");
builder.Append(Sharpen.Runtime.GetLocalHost().ToString());
Log.Info("Local Ip addresses: " + builder.ToString());
conf.SetStrings(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(superUserShortName), builder.ToString());
}
public static void Setup()
{
string currentUser = Runtime.GetProperty("user.name");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(currentUser), "*");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(currentUser), "*");
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
cluster = new MiniDFSCluster.Builder(config).NumDataNodes(1).Build();
cluster.WaitActive();
hdfs = cluster.GetFileSystem();
nn = cluster.GetNameNode();
// Use emphral port in case tests are running in parallel
config.SetInt("nfs3.mountd.port", 0);
config.SetInt("nfs3.server.port", 0);
// Start nfs
Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3 nfs3 = new Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3
(config);
nfs3.StartServiceInternal(false);
nfsd = (RpcProgramNfs3)nfs3.GetRpcProgram();
securityHandler = Org.Mockito.Mockito.Mock <SecurityHandler>();
Org.Mockito.Mockito.When(securityHandler.GetUser()).ThenReturn(Runtime.GetProperty
("user.name"));
}
/// <summary>Run MiniBenchmark using delegation token authentication.</summary>
/// <param name="conf">- configuration</param>
/// <param name="count">- connect this many times</param>
/// <param name="keytabKey">- key for keytab file in the configuration</param>
/// <param name="userNameKey">- key for user name in the configuration</param>
/// <returns>average time to connect</returns>
/// <exception cref="System.IO.IOException"/>
internal virtual long RunMiniBenchmarkWithDelegationToken(Configuration conf, int
count, string keytabKey, string userNameKey)
{
// get login information
string user = Runtime.GetProperty("user.name");
if (userNameKey != null)
{
user = conf.Get(userNameKey, user);
}
string keytabFile = null;
if (keytabKey != null)
{
keytabFile = conf.Get(keytabKey, keytabFile);
}
MiniRPCBenchmark.MiniServer miniServer = null;
UserGroupInformation.SetConfiguration(conf);
string shortUserName = UserGroupInformation.CreateRemoteUser(user).GetShortUserName
();
try
{
conf.SetStrings(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(shortUserName), GroupName1);
ConfigureSuperUserIPAddresses(conf, shortUserName);
// start the server
miniServer = new MiniRPCBenchmark.MiniServer(conf, user, keytabFile);
IPEndPoint addr = miniServer.GetAddress();
ConnectToServerAndGetDelegationToken(conf, addr);
// connect to the server count times
SetLoggingLevel(logLevel);
long elapsed = 0L;
for (int idx = 0; idx < count; idx++)
{
elapsed += ConnectToServerUsingDelegationToken(conf, addr);
}
return(elapsed);
}
finally
{
if (miniServer != null)
{
miniServer.Stop();
}
}
}
public static void SetUp()
{
config = new HdfsConfiguration();
config.SetBoolean(DFSConfigKeys.DfsWebhdfsEnabledKey, true);
config.SetLong(DFSConfigKeys.DfsNamenodeDelegationTokenMaxLifetimeKey, 10000);
config.SetLong(DFSConfigKeys.DfsNamenodeDelegationTokenRenewIntervalKey, 5000);
config.SetStrings(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(RealUser), "group1");
config.SetBoolean(DFSConfigKeys.DfsNamenodeDelegationTokenAlwaysUseKey, true);
ConfigureSuperUserIPAddresses(config, RealUser);
FileSystem.SetDefaultUri(config, "hdfs://localhost:" + "0");
cluster = new MiniDFSCluster.Builder(config).Build();
cluster.WaitActive();
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
ugi = UserGroupInformation.CreateRemoteUser(RealUser);
proxyUgi = UserGroupInformation.CreateProxyUserForTesting(ProxyUser, ugi, GroupNames
);
}
public static void Setup()
{
string currentUser = Runtime.GetProperty("user.name");
config.Set("fs.permissions.umask-mode", "u=rwx,g=,o=");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(currentUser), "*");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(currentUser), "*");
fsHelper = new FileSystemTestHelper();
// Set up java key store
string testRoot = fsHelper.GetTestRootDir();
testRootDir = new FilePath(testRoot).GetAbsoluteFile();
Path jksPath = new Path(testRootDir.ToString(), "test.jks");
config.Set(DFSConfigKeys.DfsEncryptionKeyProviderUri, JavaKeyStoreProvider.SchemeName
+ "://file" + jksPath.ToUri());
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
cluster = new MiniDFSCluster.Builder(config).NumDataNodes(1).Build();
cluster.WaitActive();
hdfs = cluster.GetFileSystem();
nn = cluster.GetNameNode();
dfsAdmin = new HdfsAdmin(cluster.GetURI(), config);
// Use ephemeral ports in case tests are running in parallel
config.SetInt("nfs3.mountd.port", 0);
config.SetInt("nfs3.server.port", 0);
// Start NFS with allowed.hosts set to "* rw"
config.Set("dfs.nfs.exports.allowed.hosts", "* rw");
nfs = new Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3(config);
nfs.StartServiceInternal(false);
nfsd = (RpcProgramNfs3)nfs.GetRpcProgram();
hdfs.GetClient().SetKeyProvider(nn.GetNamesystem().GetProvider());
DFSTestUtil.CreateKey(TestKey, cluster, config);
// Mock SecurityHandler which returns system user.name
securityHandler = Org.Mockito.Mockito.Mock <SecurityHandler>();
Org.Mockito.Mockito.When(securityHandler.GetUser()).ThenReturn(currentUser);
// Mock SecurityHandler which returns a dummy username "harry"
securityHandlerUnpriviledged = Org.Mockito.Mockito.Mock <SecurityHandler>();
Org.Mockito.Mockito.When(securityHandlerUnpriviledged.GetUser()).ThenReturn("harry"
);
}
public virtual void TestRealUserIPAuthorizationFailure()
{
Configuration conf = new Configuration();
conf.SetStrings(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(RealUserShortName), "20.20.20.20");
//Authorized IP address
conf.SetStrings(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(RealUserShortName), "group1");
Server server = new RPC.Builder(conf).SetProtocol(typeof(TestDoAsEffectiveUser.TestProtocol
)).SetInstance(new TestDoAsEffectiveUser.TestImpl(this)).SetBindAddress(Address)
.SetPort(0).SetNumHandlers(2).SetVerbose(false).Build();
RefreshConf(conf);
try
{
server.Start();
IPEndPoint addr = NetUtils.GetConnectAddress(server);
UserGroupInformation realUserUgi = UserGroupInformation.CreateRemoteUser(RealUserName
);
UserGroupInformation proxyUserUgi = UserGroupInformation.CreateProxyUserForTesting
(ProxyUserName, realUserUgi, GroupNames);
string retVal = proxyUserUgi.DoAs(new _PrivilegedExceptionAction_276(this, addr,
conf));
NUnit.Framework.Assert.Fail("The RPC must have failed " + retVal);
}
catch (Exception e)
{
Runtime.PrintStackTrace(e);
}
finally
{
server.Stop();
if (proxy != null)
{
RPC.StopProxy(proxy);
}
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void TestRealUserAuthorizationSuccess()
{
Configuration conf = new Configuration();
ConfigureSuperUserIPAddresses(conf, RealUserShortName);
conf.SetStrings(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(RealUserShortName), "group1");
Server server = new RPC.Builder(conf).SetProtocol(typeof(TestDoAsEffectiveUser.TestProtocol
)).SetInstance(new TestDoAsEffectiveUser.TestImpl(this)).SetBindAddress(Address)
.SetPort(0).SetNumHandlers(2).SetVerbose(false).Build();
RefreshConf(conf);
try
{
server.Start();
UserGroupInformation realUserUgi = UserGroupInformation.CreateRemoteUser(RealUserName
);
CheckRemoteUgi(server, realUserUgi, conf);
UserGroupInformation proxyUserUgi = UserGroupInformation.CreateProxyUserForTesting
(ProxyUserName, realUserUgi, GroupNames);
CheckRemoteUgi(server, proxyUserUgi, conf);
}
catch (Exception e)
{
Runtime.PrintStackTrace(e);
NUnit.Framework.Assert.Fail();
}
finally
{
server.Stop();
if (proxy != null)
{
RPC.StopProxy(proxy);
}
}
}
public virtual void TestRefreshSuperUserGroupsConfiguration()
{
string SuperUser = "******";
string[] GroupNames1 = new string[] { "gr1", "gr2" };
string[] GroupNames2 = new string[] { "gr3", "gr4" };
//keys in conf
string userKeyGroups = DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(SuperUser);
string userKeyHosts = DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(SuperUser);
config.Set(userKeyGroups, "gr3,gr4,gr5");
// superuser can proxy for this group
config.Set(userKeyHosts, "127.0.0.1");
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
UserGroupInformation ugi1 = Org.Mockito.Mockito.Mock <UserGroupInformation>();
UserGroupInformation ugi2 = Org.Mockito.Mockito.Mock <UserGroupInformation>();
UserGroupInformation suUgi = Org.Mockito.Mockito.Mock <UserGroupInformation>();
Org.Mockito.Mockito.When(ugi1.GetRealUser()).ThenReturn(suUgi);
Org.Mockito.Mockito.When(ugi2.GetRealUser()).ThenReturn(suUgi);
Org.Mockito.Mockito.When(suUgi.GetShortUserName()).ThenReturn(SuperUser);
// super user
Org.Mockito.Mockito.When(suUgi.GetUserName()).ThenReturn(SuperUser + "L");
// super user
Org.Mockito.Mockito.When(ugi1.GetShortUserName()).ThenReturn("user1");
Org.Mockito.Mockito.When(ugi2.GetShortUserName()).ThenReturn("user2");
Org.Mockito.Mockito.When(ugi1.GetUserName()).ThenReturn("userL1");
Org.Mockito.Mockito.When(ugi2.GetUserName()).ThenReturn("userL2");
// set groups for users
Org.Mockito.Mockito.When(ugi1.GetGroupNames()).ThenReturn(GroupNames1);
Org.Mockito.Mockito.When(ugi2.GetGroupNames()).ThenReturn(GroupNames2);
// check before
try
{
ProxyUsers.Authorize(ugi1, "127.0.0.1");
NUnit.Framework.Assert.Fail("first auth for " + ugi1.GetShortUserName() + " should've failed "
);
}
catch (AuthorizationException)
{
// expected
System.Console.Error.WriteLine("auth for " + ugi1.GetUserName() + " failed");
}
try
{
ProxyUsers.Authorize(ugi2, "127.0.0.1");
System.Console.Error.WriteLine("auth for " + ugi2.GetUserName() + " succeeded");
}
catch (AuthorizationException e)
{
// expected
NUnit.Framework.Assert.Fail("first auth for " + ugi2.GetShortUserName() + " should've succeeded: "
+ e.GetLocalizedMessage());
}
// refresh will look at configuration on the server side
// add additional resource with the new value
// so the server side will pick it up
string rsrc = "testGroupMappingRefresh_rsrc.xml";
AddNewConfigResource(rsrc, userKeyGroups, "gr2", userKeyHosts, "127.0.0.1");
DFSAdmin admin = new DFSAdmin(config);
string[] args = new string[] { "-refreshSuperUserGroupsConfiguration" };
admin.Run(args);
try
{
ProxyUsers.Authorize(ugi2, "127.0.0.1");
NUnit.Framework.Assert.Fail("second auth for " + ugi2.GetShortUserName() + " should've failed "
);
}
catch (AuthorizationException)
{
// expected
System.Console.Error.WriteLine("auth for " + ugi2.GetUserName() + " failed");
}
try
{
ProxyUsers.Authorize(ugi1, "127.0.0.1");
System.Console.Error.WriteLine("auth for " + ugi1.GetUserName() + " succeeded");
}
catch (AuthorizationException e)
{
// expected
NUnit.Framework.Assert.Fail("second auth for " + ugi1.GetShortUserName() + " should've succeeded: "
+ e.GetLocalizedMessage());
}
}
public virtual void TestGetProxyUgi()
{
conf.Set(DFSConfigKeys.FsDefaultNameKey, "hdfs://localhost:4321/");
ServletContext context = Org.Mockito.Mockito.Mock <ServletContext>();
string realUser = "******";
string user = "******";
conf.Set(DFSConfigKeys.HadoopSecurityAuthentication, "kerberos");
conf.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(realUser), "*");
conf.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(realUser), "*");
ProxyUsers.RefreshSuperUserGroupsConfiguration(conf);
UserGroupInformation.SetConfiguration(conf);
UserGroupInformation ugi;
HttpServletRequest request;
// have to be auth-ed with remote user
request = GetMockRequest(null, null, user);
try
{
JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.Fail("bad request allowed");
}
catch (IOException ioe)
{
NUnit.Framework.Assert.AreEqual("Security enabled but user not authenticated by filter"
, ioe.Message);
}
request = GetMockRequest(null, realUser, user);
try
{
JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.Fail("bad request allowed");
}
catch (IOException ioe)
{
NUnit.Framework.Assert.AreEqual("Security enabled but user not authenticated by filter"
, ioe.Message);
}
// proxy ugi for user via remote user
request = GetMockRequest(realUser, null, user);
ugi = JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.IsNotNull(ugi.GetRealUser());
NUnit.Framework.Assert.AreEqual(ugi.GetRealUser().GetShortUserName(), realUser);
NUnit.Framework.Assert.AreEqual(ugi.GetShortUserName(), user);
CheckUgiFromAuth(ugi);
// proxy ugi for user vi a remote user = real user
request = GetMockRequest(realUser, realUser, user);
ugi = JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.IsNotNull(ugi.GetRealUser());
NUnit.Framework.Assert.AreEqual(ugi.GetRealUser().GetShortUserName(), realUser);
NUnit.Framework.Assert.AreEqual(ugi.GetShortUserName(), user);
CheckUgiFromAuth(ugi);
// proxy ugi for user via remote user != real user
request = GetMockRequest(realUser, user, user);
try
{
JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.Fail("bad request allowed");
}
catch (IOException ioe)
{
NUnit.Framework.Assert.AreEqual("Usernames not matched: name=" + user + " != expected="
+ realUser, ioe.Message);
}
// try to get get a proxy user with unauthorized user
try
{
request = GetMockRequest(user, null, realUser);
JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.Fail("bad proxy request allowed");
}
catch (AuthorizationException ae)
{
NUnit.Framework.Assert.AreEqual("User: "******" is not allowed to impersonate "
+ realUser, ae.Message);
}
try
{
request = GetMockRequest(user, user, realUser);
JspHelper.GetUGI(context, request, conf);
NUnit.Framework.Assert.Fail("bad proxy request allowed");
}
catch (AuthorizationException ae)
{
NUnit.Framework.Assert.AreEqual("User: "******" is not allowed to impersonate "
+ realUser, ae.Message);
}
}
public virtual void TestOOOWrites()
{
NfsConfiguration config = new NfsConfiguration();
MiniDFSCluster cluster = null;
RpcProgramNfs3 nfsd;
int bufSize = 32;
int numOOO = 3;
SecurityHandler securityHandler = Org.Mockito.Mockito.Mock <SecurityHandler>();
Org.Mockito.Mockito.When(securityHandler.GetUser()).ThenReturn(Runtime.GetProperty
("user.name"));
string currentUser = Runtime.GetProperty("user.name");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(currentUser), "*");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(currentUser), "*");
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
// Use emphral port in case tests are running in parallel
config.SetInt("nfs3.mountd.port", 0);
config.SetInt("nfs3.server.port", 0);
try
{
cluster = new MiniDFSCluster.Builder(config).NumDataNodes(1).Build();
cluster.WaitActive();
Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3 nfs3 = new Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3
(config);
nfs3.StartServiceInternal(false);
nfsd = (RpcProgramNfs3)nfs3.GetRpcProgram();
DFSClient dfsClient = new DFSClient(NameNode.GetAddress(config), config);
HdfsFileStatus status = dfsClient.GetFileInfo("/");
FileHandle rootHandle = new FileHandle(status.GetFileId());
CREATE3Request createReq = new CREATE3Request(rootHandle, "out-of-order-write" +
Runtime.CurrentTimeMillis(), Nfs3Constant.CreateUnchecked, new SetAttr3(), 0);
XDR createXdr = new XDR();
createReq.Serialize(createXdr);
CREATE3Response createRsp = nfsd.Create(createXdr.AsReadOnlyWrap(), securityHandler
, new IPEndPoint("localhost", 1234));
FileHandle handle = createRsp.GetObjHandle();
byte[][] oooBuf = new byte[][] { new byte[bufSize], new byte[bufSize], new byte[bufSize
] };
for (int i = 0; i < numOOO; i++)
{
Arrays.Fill(oooBuf[i], unchecked ((byte)i));
}
for (int i_1 = 0; i_1 < numOOO; i_1++)
{
long offset = (numOOO - 1 - i_1) * bufSize;
WRITE3Request writeReq = new WRITE3Request(handle, offset, bufSize, Nfs3Constant.WriteStableHow
.Unstable, ByteBuffer.Wrap(oooBuf[i_1]));
XDR writeXdr = new XDR();
writeReq.Serialize(writeXdr);
nfsd.Write(writeXdr.AsReadOnlyWrap(), null, 1, securityHandler, new IPEndPoint("localhost"
, 1234));
}
WaitWrite(nfsd, handle, 60000);
READ3Request readReq = new READ3Request(handle, bufSize, bufSize);
XDR readXdr = new XDR();
readReq.Serialize(readXdr);
READ3Response readRsp = nfsd.Read(readXdr.AsReadOnlyWrap(), securityHandler, new
IPEndPoint("localhost", config.GetInt(NfsConfigKeys.DfsNfsServerPortKey, NfsConfigKeys
.DfsNfsServerPortDefault)));
NUnit.Framework.Assert.IsTrue(Arrays.Equals(oooBuf[1], ((byte[])readRsp.GetData()
.Array())));
}
finally
{
if (cluster != null)
{
cluster.Shutdown();
}
}
}
public virtual void TestWriteStableHow()
{
NfsConfiguration config = new NfsConfiguration();
DFSClient client = null;
MiniDFSCluster cluster = null;
RpcProgramNfs3 nfsd;
SecurityHandler securityHandler = Org.Mockito.Mockito.Mock <SecurityHandler>();
Org.Mockito.Mockito.When(securityHandler.GetUser()).ThenReturn(Runtime.GetProperty
("user.name"));
string currentUser = Runtime.GetProperty("user.name");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserGroupConfKey
(currentUser), "*");
config.Set(DefaultImpersonationProvider.GetTestProvider().GetProxySuperuserIpConfKey
(currentUser), "*");
ProxyUsers.RefreshSuperUserGroupsConfiguration(config);
try
{
cluster = new MiniDFSCluster.Builder(config).NumDataNodes(1).Build();
cluster.WaitActive();
client = new DFSClient(NameNode.GetAddress(config), config);
// Use emphral port in case tests are running in parallel
config.SetInt("nfs3.mountd.port", 0);
config.SetInt("nfs3.server.port", 0);
// Start nfs
Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3 nfs3 = new Org.Apache.Hadoop.Hdfs.Nfs.Nfs3.Nfs3
(config);
nfs3.StartServiceInternal(false);
nfsd = (RpcProgramNfs3)nfs3.GetRpcProgram();
HdfsFileStatus status = client.GetFileInfo("/");
FileHandle rootHandle = new FileHandle(status.GetFileId());
// Create file1
CREATE3Request createReq = new CREATE3Request(rootHandle, "file1", Nfs3Constant.CreateUnchecked
, new SetAttr3(), 0);
XDR createXdr = new XDR();
createReq.Serialize(createXdr);
CREATE3Response createRsp = nfsd.Create(createXdr.AsReadOnlyWrap(), securityHandler
, new IPEndPoint("localhost", 1234));
FileHandle handle = createRsp.GetObjHandle();
// Test DATA_SYNC
byte[] buffer = new byte[10];
for (int i = 0; i < 10; i++)
{
buffer[i] = unchecked ((byte)i);
}
WRITE3Request writeReq = new WRITE3Request(handle, 0, 10, Nfs3Constant.WriteStableHow
.DataSync, ByteBuffer.Wrap(buffer));
XDR writeXdr = new XDR();
writeReq.Serialize(writeXdr);
nfsd.Write(writeXdr.AsReadOnlyWrap(), null, 1, securityHandler, new IPEndPoint("localhost"
, 1234));
WaitWrite(nfsd, handle, 60000);
// Readback
READ3Request readReq = new READ3Request(handle, 0, 10);
XDR readXdr = new XDR();
readReq.Serialize(readXdr);
READ3Response readRsp = nfsd.Read(readXdr.AsReadOnlyWrap(), securityHandler, new
IPEndPoint("localhost", 1234));
NUnit.Framework.Assert.IsTrue(Arrays.Equals(buffer, ((byte[])readRsp.GetData().Array
())));
// Test FILE_SYNC
// Create file2
CREATE3Request createReq2 = new CREATE3Request(rootHandle, "file2", Nfs3Constant.
CreateUnchecked, new SetAttr3(), 0);
XDR createXdr2 = new XDR();
createReq2.Serialize(createXdr2);
CREATE3Response createRsp2 = nfsd.Create(createXdr2.AsReadOnlyWrap(), securityHandler
, new IPEndPoint("localhost", 1234));
FileHandle handle2 = createRsp2.GetObjHandle();
WRITE3Request writeReq2 = new WRITE3Request(handle2, 0, 10, Nfs3Constant.WriteStableHow
.FileSync, ByteBuffer.Wrap(buffer));
XDR writeXdr2 = new XDR();
writeReq2.Serialize(writeXdr2);
nfsd.Write(writeXdr2.AsReadOnlyWrap(), null, 1, securityHandler, new IPEndPoint("localhost"
, 1234));
WaitWrite(nfsd, handle2, 60000);
// Readback
READ3Request readReq2 = new READ3Request(handle2, 0, 10);
XDR readXdr2 = new XDR();
readReq2.Serialize(readXdr2);
READ3Response readRsp2 = nfsd.Read(readXdr2.AsReadOnlyWrap(), securityHandler, new
IPEndPoint("localhost", 1234));
NUnit.Framework.Assert.IsTrue(Arrays.Equals(buffer, ((byte[])readRsp2.GetData().Array
())));
// FILE_SYNC should sync the file size
status = client.GetFileInfo("/file2");
NUnit.Framework.Assert.IsTrue(status.GetLen() == 10);
}
finally
{
if (cluster != null)
{
cluster.Shutdown();
}
}
}
