static void Main(string[] args)
{
try
{
FPLogger.ConsoleMessage("\nCluster to connect to [" + clusterAddress + "]: ");
String answer = Console.ReadLine();
if (answer != "")
{
clusterAddress = answer;
}
FPPool myPool = new FPPool(clusterAddress);
FPLogger.ConsoleMessage("\nEnter the content address of the clip to manage: ");
String clipID = Console.ReadLine();
FPClip clipRef = myPool.ClipOpen(clipID, FPMisc.OPEN_ASTREE);
FPLogger.ConsoleMessage("\nThe following RetentionClasses are configured in the pool:\n");
foreach (FPRetentionClass rc in myPool.RetentionClasses)
{
FPLogger.ConsoleMessage(rc.ToString());
}
FPLogger.ConsoleMessage("\nEnter RetentionClass or Period (in seconds) to be set: ");
String newValue = Console.ReadLine();
if (myPool.RetentionClasses.ValidateClass(newValue))
{
clipRef.RetentionClassName = newValue;
}
else
{
clipRef.RetentionPeriod = new TimeSpan(0, 0, int.Parse(newValue));
}
clipID = clipRef.Write();
FPLogger.ConsoleMessage("\nThe new content address for the clip is " + clipID);
FPLogger.ConsoleMessage("\nCluster time " + myPool.ClusterTime);
FPLogger.ConsoleMessage("\nClip created " + clipRef.CreationDate);
FPLogger.ConsoleMessage("\nThe retention period " + clipRef.RetentionPeriod);
FPLogger.ConsoleMessage("\nThe retention will expire on " + clipRef.RetentionExpiry);
clipRef.Close();
}
catch (FPLibraryException e)
{
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: Error " + err.error + " " + err.message);
}
catch (Exception e)
{
FPLogger.ConsoleMessage("\nException thrown! " + e.Message);
}
}
static void Main(string[] args)
{
try
{
FPLogger.ConsoleMessage("\nCluster to connect to [" + defaultCluster + "] : ");
String clusterAddress = System.Console.ReadLine();
if ("" == clusterAddress)
{
clusterAddress = defaultCluster;
}
FPLogger.ConsoleMessage("\nEnter the name of the file containing the clip to be restored: ");
String fileName = Console.ReadLine();
if (!fileName.EndsWith(".xml"))
{
FPLogger.ConsoleMessage("\nInvalid file name format - should be <clipID>.xml");
return;
}
String clipID = fileName.Substring(0, fileName.Length - 4);
FPPool thePool = new FPPool(clusterAddress);
FPStream fpStream = new FPStream(fileName, 16 * 1024);
// Create the clip
FPClip clipRef = thePool.ClipRawOpen(clipID, fpStream, FPMisc.OPTION_DEFAULT_OPTIONS);
FPTag t = clipRef.NextTag;
fpStream = new FPStream(clipID + ".Tag.0", 16 * 1024);
t.BlobWrite(fpStream, FPMisc.OPTION_DEFAULT_OPTIONS);
fpStream.Close();
t.Close();
t = clipRef.NextTag;
fpStream = new FPStream(clipID + ".Tag.1", 16 * 1024);
t.BlobWrite(fpStream, FPMisc.OPTION_DEFAULT_OPTIONS);
fpStream.Close();
t.Close();
clipRef.Write();
clipRef.Close();
thePool.Close();
FPLogger.ConsoleMessage("\nClip and Blobs successfully restored to Cluster");
}
catch (FPLibraryException e)
{
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: Error " + err.error + " " + err.message);
}
}
static void Main(string[] args)
{
IntPtr userData = new IntPtr(0);
string clipID;
BinaryReader myReader;
BinaryWriter myWriter;
BlobStream myStream;
// For thsi test we are using a file as the input. *Any* stream could be used.
// This would be your test PDF - in a file or memory stream.
FileStream inputStream = new FileStream("e:\\testfile", FileMode.Open);
FPLogger.ConsoleMessage("\nInput file length " + inputStream.Length);
try
{
FPLogger log = new FPLogger();
log.LogPath = "C:\\GenStreamsLog.txt";
log.Start();
// Create a test clip demonstrating how to write a blob using a stream
FPPool myPool = new FPPool("cse1.centera.lab.emc.com");
FPClip myClip = myPool.ClipCreate("GenericStreamWrite_testClip");
FPTag myTag = myClip.AddTag("testTag");
// Simple test of the BlobWriteStream - write contents of a local file
// to Centera using a StreamReader and StreamWriter
// We are using a temporary MemoryStream for our staging area
myStream = new BlobWriteStream(myTag);
myReader = new BinaryReader(inputStream);
myWriter = new BinaryWriter(myStream);
long writeTime1 = DateTime.Now.Ticks;
myWriter.Write(myReader.ReadBytes((int)inputStream.Length));
myWriter.Flush();
((BlobWriteStream)myStream).Close(); // If we don't do this it will stay open forever with keep alives!
writeTime1 = DateTime.Now.Ticks - writeTime1;
// If we assign values to existing FP objects we must explicitly close
// them first to avoid potential "Object In Use" errors on future closure
myTag.Close();
myTag = myClip.AddTag("SlicedBlob");
inputStream.Seek(0, SeekOrigin.Begin);
long writeTime = DateTime.Now.Ticks;
SlicedBlobWriter.Instance(inputStream, myTag, 8);
writeTime = DateTime.Now.Ticks - writeTime;
myTag.Close();
clipID = myClip.Write();
myClip.Close();
FPLogger.ConsoleMessage("\nGenericStreamWrite test succeeded " + clipID);
// Now we will test reading it back from the Centera {
myClip = myPool.ClipOpen(clipID, FPMisc.OPEN_ASTREE);
myTag = myClip.NextTag;
// Here we create a stream to read back the blob
long readTime1 = DateTime.Now.Ticks;
myStream = new BlobReadStream(myTag);
// This is only to test to verify when we read the content back it is the same as the
// input file i.e. we are going to store it on the file system and then use file system tools
// to compare the files
myReader = new BinaryReader(myStream);
myWriter = new BinaryWriter(new FileStream("c:\\testfile2.out", FileMode.Create));
((BlobReadStream)myStream).Join();
myWriter.Write(myReader.ReadBytes((int)myTag.BlobSize));
myWriter.Flush();
myStream.Close();
readTime1 = DateTime.Now.Ticks - readTime1;
myTag.Close();
// This shows how to read content back using multiple threads
myTag = myClip.NextTag;
long readTime = DateTime.Now.Ticks;
SlicedBlobReader.Instance(new FileStream("c:\\testfile2.out.sliced", FileMode.Create), myTag, 8);
readTime = DateTime.Now.Ticks - readTime;
myTag.Close();
myClip.Close();
myPool.Close();
FPLogger.ConsoleMessage("\nSerial tests - Write time: " + TimeSpan.FromTicks(writeTime1) + " Read time " + TimeSpan.FromTicks(readTime1));
FPLogger.ConsoleMessage("\nMulti threaded tests - Write time: " + TimeSpan.FromTicks(writeTime) + " Read time " + TimeSpan.FromTicks(readTime));
}
catch (FPLibraryException e)
{
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: Error " + err.error + " " + err.message);
}
}
static void Main(string[] args)
{
IntPtr userData = new IntPtr(0);
try
{
FPPool myPool = new FPPool("128.221.200.56?c:\\pea\\emea1.pea");
FPTag myTag;
FPLogger log = new FPLogger();
log.LogPath = "C:\\GenStreamsLog.txt";
log.Start();
// First we'll write a test clip to the Centera
string fileName = "c:\\discovery.xml";
FileInfo info = new FileInfo(fileName);
FPClip myClip = myPool.ClipCreate("GenericStreamWrite_testClip");
myTag = myClip.AddTag("testTag");
FPGenericStream myStream = new FPGenericStream(File.OpenRead(fileName), userData);
myStream.StreamLen = info.Length;
myTag.BlobWrite(myStream);
myTag.Close();
myStream.Close();
string clipID = myClip.Write();
myClip.Close();
FPLogger.ConsoleMessage("\nGenericStreamWrite test succeeded");
// Now we will test reading it back from the Centera {
myClip = myPool.ClipOpen(clipID, FPMisc.OPEN_ASTREE);
myTag = myClip.NextTag;
myStream = new FPGenericStream(File.OpenWrite("c:\\test.out"), userData);
myStream.StreamLen = myTag.BlobSize;
myTag.BlobRead(myStream);
myStream.Close();
FPLogger.ConsoleMessage("\nGenericStreamRead test succeeded for FileStream");
// We could use a Memory stream. As it is a bi-directional stream we
// need to use a ctor that specifies the direction we want to use.
// We'll set up the space first.
MemoryStream s = new MemoryStream((int)myTag.BlobSize);
myStream = new FPGenericStream(s, FPStream.StreamDirection.OutputFromCentera, userData);
myStream.StreamLen = myTag.BlobSize;
myTag.BlobRead(myStream, FPMisc.OPTION_DEFAULT_OPTIONS);
myStream.Close();
FPLogger.ConsoleMessage("\nGenericStreamRead test succeeded for MemoryStream");
myTag.Close();
myClip.Close();
myPool.Close();
}
catch (FPLibraryException e)
{
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: Error " + err.error + " " + err.message);
}
}
static void Main(string[] args)
{
try
{
string clipID;
FPLogger.ConsoleMessage("\nEnter cluster to connect to [" + clusterAddress + "]: ");
String answer = Console.ReadLine();
if (answer != "")
{
clusterAddress = answer;
}
using (FPPool myPool = new FPPool(clusterAddress))
{
FPLogger.ConsoleMessage("\nEBR supported: " + myPool.EBRSupported);
FPLogger.ConsoleMessage("\nHold Supported: " + myPool.HoldSupported);
FPLogger.ConsoleMessage("\nHold allowed: " + myPool.HoldAllowed);
FPLogger.ConsoleMessage("\nCluster time is " + myPool.ClusterTime);
FPLogger.ConsoleMessage("\nMin retention periods: F:" + myPool.FixedRetentionMin + " V:" + myPool.VariableRetentionMin);
// By utilising the "using" clause we can allow for the
// dispose method to tidy the Pool connection
// Create a test clip that we will use to show the way EBR works
FPClip testClip = myPool.ClipCreate("testClip");
testClip.RetentionPeriod = new TimeSpan(0, 0, 1); // myPool.FixedRetentionMin;
testClip.EBRPeriod = new TimeSpan(0, 0, 4); // myPool.VariableRetentionMin;
clipID = testClip.Write();
FPLogger.ConsoleMessage("\nCreated test clip " + clipID);
FPLogger.ConsoleMessage("\nCluster time is " + myPool.ClusterTime +
"\nFixed Retention expires " + testClip.RetentionExpiry);
//testClip.Close();
// Check that we cannot delete the clip because the EBR Event has not fired
Thread.Sleep(1005);
try
{
myPool.ClipDelete(clipID);
}
catch (FPLibraryException e)
{
// You cannot delete a clip with EBR enabled before the EBREventhappens!
FPLogger.ConsoleMessage("\nTried to delete Clip before EBR Event occurred");
FPLogger.ConsoleMessage("\n\t" + e.errorInfo.error + " " + e.errorInfo);
}
// Here's how we fire the EBR Event on an existing clip that is effectively
// in a "wait" state. As the mutable metadata associated with
// the clip is being modified you need to open it in TREE mode.
// We could equally have used TriggerEBRPeriod here to set a different
// value to that which we originally used when putting the clip in the
// "wait" state.
//testClip = myPool.ClipOpen(clipID, FPMisc.OPEN_ASTREE);
testClip.TriggerEBREvent();
testClip.Write();
FPLogger.ConsoleMessage("\nEBR event triggered: expires on " + testClip.EBRExpiry);
// You cannot trigger the Event twice. If you do try and do this
// then you get an nasty -10160 FP_EBR_OVERRIDE_ERR. This seems to invalidate
// SDK reference objects so we can't demonstrate it!
Thread.Sleep(2005);
// At this point, the EBR Event has occurred but the period
// has the not expired
try
{
FPLogger.ConsoleMessage("\nCluster time is " + myPool.ClusterTime +
"\nFixed Retention expires " + testClip.RetentionExpiry +
"\nEBR expires " + testClip.EBRExpiry);
myPool.ClipDelete(clipID);
}
catch (FPLibraryException e)
{
FPLogger.ConsoleMessage("\nTried to delete clip before EBR period expired");
FPLogger.ConsoleMessage("\n\t" + e.errorInfo.error + " " + e.errorInfo);
}
// Let's wait and try it again later
Thread.Sleep(4005);
FPLogger.ConsoleMessage("\nCluster time is " + myPool.ClusterTime +
"\nFixed Retention expires " + testClip.RetentionExpiry +
"\nEBR expires " + testClip.EBRExpiry);
testClip.Close();
myPool.ClipDelete(clipID);
FPLogger.ConsoleMessage("\nClip successfully deleted as EBR and fixed retention periods have expired");
}
}
catch (FPLibraryException e)
{
if (e.errorInfo.error.Equals(FPMisc.OUT_OF_BOUNDS_ERR))
{
FPLogger.ConsoleMessage("\nThe cluster is configured with Mimumum Retention governors " +
"whose values are too high to use this sample");
}
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: " + e);
}
}
static void Main(string[] args)
{
try
{
FPLogger.ConsoleMessage("\nCluster to connect to [" + clusterAddress + "]: ");
String answer = Console.ReadLine();
if (answer != "")
{
clusterAddress = answer;
}
FPPool myPool = new FPPool(clusterAddress);
// Check that we can use LitigationHold
// This property checks that it is supported on the cluster
// and also that we have the capability granted to use it
if (!myPool.HoldAllowed)
{
FPLogger.ConsoleMessage("\nRetention Hold is not supported");
}
else
{
FPClip testClip = myPool.ClipCreate("testClip");
testClip.RetentionPeriod = new TimeSpan(0);
string clipID = testClip.Write();
FPLogger.ConsoleMessage("\nCreated testClip " + clipID + "\n");
// We now have a test clip with no retention set, which would normally
// mean that we can always delete it.
// Let's place it under LitigationHold and see what happens.
testClip.SetRetentionHold(true, "123456789");
clipID = testClip.Write();
testClip.Close();
// Multiple holds can be set on a clip so let's set another one just to
// demonstrate how it is done. As the mutable metadata associated with
// the clip is being modified you need to open it in TREE mode.
testClip = myPool.ClipOpen(clipID, FPMisc.OPEN_ASTREE);
testClip.SetRetentionHold(true, "ABCDEFG");
clipID = testClip.Write();
FPLogger.ConsoleMessage("\nClip " + clipID + " now under holds '123456789' and 'ABCDEFG'");
try
{
myPool.ClipDelete(clipID);
}
catch (FPLibraryException e)
{
FPLogger.ConsoleMessage("\nTrying to delete clip that is under Litigation Hold: ");
FPLogger.ConsoleMessage("\n\t" + e.errorInfo.error + " " + e.errorInfo);
}
//Release one of the holds
testClip.SetRetentionHold(false, "123456789");
clipID = testClip.Write();
FPLogger.ConsoleMessage("\nReleased '123456789' hold but 'ABCDEFG' still active");
try
{
myPool.ClipDelete(clipID);
}
catch (FPLibraryException e)
{
FPLogger.ConsoleMessage("\nTrying to delete clip that is under Litigation Hold: ");
FPLogger.ConsoleMessage("\n\t" + e.errorInfo.error + " " + e.errorInfo);
}
// Release the other hold
testClip.SetRetentionHold(false, "ABCDEFG");
clipID = testClip.Write();
FPLogger.ConsoleMessage("\nReleased 'ABCDEFG' hold");
testClip.Close();
myPool.ClipDelete(clipID);
FPLogger.ConsoleMessage("\nAll holds released, delete was allowed on " + clipID);
}
myPool.Close();
}
catch (FPLibraryException e)
{
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: " + e);
}
}
static void Main(string[] args)
{
try
{
FPLogger.ConsoleMessage("\nCluster to connect to [" + defaultCluster + "] : ");
String clusterAddress = System.Console.ReadLine();
if ("" == clusterAddress)
{
clusterAddress = defaultCluster;
}
UTF8Encoding converter2 = new UTF8Encoding();
// We are going to create a filename containing Chinese characters
byte[] inputFileName = { 0xE6, 0x98, 0x8E, 0xE5, 0xA4, 0xA9, 0x2E, 0x74, 0x78, 0x74 };
string fileName = System.Text.Encoding.UTF8.GetString(inputFileName);
File.WriteAllText(fileName, "Test file with wide characters in the file name\n");
FPLogger.ConsoleMessage("\nEnter the threshold to use for Embedded Blobs: ");
String blobString = System.Console.ReadLine();
if (blobString == "")
{
blobString = "0";
}
int blobThreshold = Int32.Parse(blobString);
if (blobThreshold > 0)
{
FPLogger.ConsoleMessage("\nContent less than " + blobString + " bytes will be embedded in the CDF.");
}
else
{
FPLogger.ConsoleMessage("\nContent will never be embedded in the CDF.");
}
FPPool.EmbeddedBlobThreshold = blobThreshold;
FPPool thePool = new FPPool(clusterAddress);
// Create the clip
FPClip clipRef = new FPClip(thePool, "UTF8_Example");
clipRef.SetAttribute("OriginalFilename", fileName);
FPTag fileTag = clipRef.AddTag("WideFilenameTag");
fileTag.SetAttribute("filename", fileName);
// Write the content of the file to the Centera
FPStream streamRef = new FPWideFilenameStream(fileName);
fileTag.BlobWrite(streamRef, FPMisc.OPTION_CLIENT_CALCID);
streamRef.Close();
long blobSize = fileTag.BlobSize;
if (blobThreshold > 0 && blobSize < blobThreshold)
{
FPLogger.ConsoleMessage("\nContent was embedded in the CDF as size "
+ blobSize
+ " is less than the threshold.");
}
fileTag.Close();
fileTag = clipRef.AddTag("TestTag");
fileTag.SetAttribute("fileCabinetGuid", "52d9cf57-7261-472a-b6d9-a8cdd30d1d27");
fileTag.SetAttribute("attr2", "a second attribute");
fileTag.SetAttribute("anotherattr", "the third attribute");
/* Or you can write from a memory buffer holding the data
* The exampe uses a byte array containing a string
*/
UTF8Encoding converter = new UTF8Encoding();
byte[] rawBuffer = converter.GetBytes("This is a test string to illustrate how to interface to Centera using a buffer stream");
IntPtr source = Marshal.AllocHGlobal(rawBuffer.Length);
Marshal.Copy(rawBuffer, 0, source, rawBuffer.Length);
streamRef = new FPStream(source, rawBuffer.Length, FPStream.StreamDirection.InputToCentera);
fileTag.BlobWrite(streamRef, FPMisc.OPTION_CLIENT_CALCID);
streamRef.Close();
Marshal.FreeHGlobal(source);
fileTag.Close();
fileTag = clipRef.AddTag("TestTag2");
fileTag.SetAttribute("filename", fileName);
// We will only store a fragment of the file - "length" characters from position "offset"
long offset = 5;
long length = 30;
streamRef = new FPWideFilenameStream(fileName, offset, length);
fileTag.BlobWrite(streamRef, FPMisc.OPTION_CLIENT_CALCID);
streamRef.Close();
// And this is how we read back at most "length" characters into a file at position "offset"
// We can also specify that we don't want the created file to be larger than "maxFileSize"
long maxFileSize = 20;
streamRef = new FPWideFilenameStream(fileName + ".partial", FileMode.OpenOrCreate, offset, length, maxFileSize);
fileTag.BlobRead(streamRef);
streamRef.Close();
String clipID = clipRef.Write();
/* Write the Clip ID to the output file, "inputFileName.clipID" */
FPLogger.ConsoleMessage("\nThe C-Clip ID of the content is " + clipID);
FileStream outFile = new FileStream(fileName + ".clipID", FileMode.Create);
BinaryWriter outWriter = new BinaryWriter(outFile);
outWriter.Write(clipID.ToString() + "\n");
outWriter.Close();
outFile.Close();
fileTag.Close();
clipRef.Close();
thePool.Close();
}
catch (FPLibraryException e)
{
ErrorInfo err = e.errorInfo;
FPLogger.ConsoleMessage("\nException thrown in FP Library: Error " + err.error + " " + err.message);
}
}