public bool SendNotecard(string name, string content, UUID sendToUUID)
{
bool returnstatus = true;
name = name + " " + DateTime.Now;
Client.Inventory.RequestCreateItem(
Client.Inventory.FindFolderForType(AssetType.Notecard),
name,
name + " Created via SecondBot notecard API",
AssetType.Notecard,
UUID.Random(),
InventoryType.Notecard,
PermissionMask.All,
(bool Success, InventoryItem item) =>
{
if (Success)
{
AssetNotecard empty = new AssetNotecard {
BodyText = "\n"
};
empty.Encode();
Client.Inventory.RequestUploadNotecardAsset(empty.AssetData, item.UUID,
(bool emptySuccess, string emptyStatus, UUID emptyItemID, UUID emptyAssetID) =>
{
if (emptySuccess)
{
empty.BodyText = content;
empty.Encode();
Client.Inventory.RequestUploadNotecardAsset(empty.AssetData, emptyItemID,
(bool finalSuccess, string finalStatus, UUID finalItemID, UUID finalID) =>
{
if (finalSuccess)
{
Info("Sending notecard now");
Client.Inventory.GiveItem(finalItemID, name, AssetType.Notecard, sendToUUID, false);
}
else
{
returnstatus = false;
Warn("Unable to request notecard upload");
}
});
}
else
{
Crit("The f**k empty success notecard create");
returnstatus = false;
}
});
}
else
{
Warn("Unable to find default notecards folder");
returnstatus = false;
}
}
);
return(returnstatus);
}
private void CreateTestObjects(Scene scene, out SceneObjectGroup sog1, out SceneObjectGroup sog2, out UUID ncAssetUuid)
{
SceneObjectPart part1 = CreateSceneObjectPart1();
sog1 = new SceneObjectGroup(part1);
scene.AddNewSceneObject(sog1, false);
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
ncAssetUuid = UUID.Random();
UUID ncItemUuid = UUID.Random();
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
TaskInventoryItem ncItem
= new TaskInventoryItem {
Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid
};
SceneObjectPart part2 = CreateSceneObjectPart2();
sog2 = new SceneObjectGroup(part2);
part2.Inventory.AddInventoryItem(ncItem, true);
scene.AddNewSceneObject(sog2, false);
}
/// <summary>
/// Add a notecard item to the given part.
/// </summary>
/// <param name="assetService"></param>
/// <param name="part"></param>
/// <param name="itemName"></param>
/// <param name="itemID"></param>
/// <param name="assetID"></param>
/// <param name="text">The tex to put in the notecard.</param>
/// <returns>The item that was added</returns>
public static TaskInventoryItem AddNotecard(
IAssetService assetService, SceneObjectPart part, string itemName, UUID itemID, UUID assetID, string text)
{
AssetNotecard nc = new AssetNotecard();
nc.BodyText = text;
nc.Encode();
AssetBase ncAsset
= AssetHelpers.CreateAsset(assetID, AssetType.Notecard, nc.AssetData, UUID.Zero);
assetService.Store(ncAsset);
TaskInventoryItem ncItem
= new TaskInventoryItem
{
Name = itemName,
AssetID = assetID,
ItemID = itemID,
Type = (int)AssetType.Notecard,
InvType = (int)InventoryType.Notecard
};
part.Inventory.AddInventoryItem(ncItem, true);
return(ncItem);
}
/// <summary>
/// Create an asset from the given data.
/// </summary>
public static AssetBase CreateAsset(UUID assetUuid, AssetType assetType, string text, UUID creatorID)
{
AssetNotecard anc = new AssetNotecard();
anc.BodyText = text;
anc.Encode();
return(CreateAsset(assetUuid, assetType, anc.AssetData, creatorID));
}
private void tbtnSave_Click(object sender, EventArgs e)
{
bool success = false;
string message = "";
AssetNotecard n = new AssetNotecard
{
BodyText = rtbContent.Text,
EmbeddedItems = new List <InventoryItem>()
};
if (receivedNotecard != null)
{
for (var i = 0; i < receivedNotecard.EmbeddedItems.Count; i++)
{
n.EmbeddedItems.Add(receivedNotecard.EmbeddedItems[i]);
int indexChar = 0xdc00 + i;
n.BodyText += (char)0xdbc0;
n.BodyText += (char)indexChar;
}
}
n.Encode();
UpdateStatus("Saving...");
InventoryManager.InventoryUploadedAssetCallback handler = delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
success = uploadSuccess;
if (itemID == notecard.UUID)
{
if (success)
{
UpdateStatus("OK");
notecard.AssetUUID = assetID;
}
else
{
UpdateStatus("Failed");
}
}
message = status ?? "Unknown error uploading notecard asset";
};
if (prim == null)
{
client.Inventory.RequestUploadNotecardAsset(n.AssetData, notecard.UUID, handler);
}
else
{
client.Inventory.RequestUpdateNotecardTask(n.AssetData, notecard.UUID, prim.ID, handler);
}
}
/// <summary>
/// Add a notecard item to the given part.
/// </summary>
/// <param name="scene"></param>
/// <param name="part"></param>
/// <param name="itemName"></param>
/// <param name="itemID"></param>
/// <param name="assetID"></param>
/// <returns>The item that was added</returns>
public static TaskInventoryItem AddNotecard(Scene scene, SceneObjectPart part, string itemName, UUID itemID, UUID assetID)
{
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
AssetBase ncAsset
= AssetHelpers.CreateAsset(assetID, AssetType.Notecard, nc.AssetData, UUID.Zero);
scene.AssetService.Store(ncAsset);
TaskInventoryItem ncItem
= new TaskInventoryItem
{ Name = itemName, AssetID = assetID, ItemID = itemID,
Type = (int)AssetType.Notecard, InvType = (int)InventoryType.Notecard };
part.Inventory.AddInventoryItem(ncItem, true);
return ncItem;
}
/// <summary>
/// Add a notecard item to the given part.
/// </summary>
/// <param name="scene"></param>
/// <param name="part"></param>
/// <returns>The item that was added</returns>
public static TaskInventoryItem AddNotecard(Scene scene, SceneObjectPart part)
{
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
scene.AssetService.Store(ncAsset);
TaskInventoryItem ncItem
= new TaskInventoryItem
{ Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid,
Type = (int)AssetType.Notecard, InvType = (int)InventoryType.Notecard };
part.Inventory.AddInventoryItem(ncItem, true);
return ncItem;
}
protected TaskInventoryItem CreateSOItem1(Scene scene, SceneObjectPart part)
{
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
scene.AssetService.Store(ncAsset);
TaskInventoryItem ncItem
= new TaskInventoryItem
{
Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid,
Type = (int)AssetType.Notecard, InvType = (int)InventoryType.Notecard
};
part.Inventory.AddInventoryItem(ncItem, true);
return(ncItem);
}
public void TestSaveOarV0_2()
{
TestHelper.InMethod();
//log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem {
Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid
};
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
m_scene.EventManager.OnOarFileSaved += SaveCompleted;
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
lock (this)
{
m_archiverModule.ArchiveRegion(archiveWriteStream, requestId);
//AssetServerBase assetServer = (AssetServerBase)scene.CommsManager.AssetCache.AssetServer;
//while (assetServer.HasWaitingRequests())
// assetServer.ProcessNextRequest();
Monitor.Wait(this, 60000);
}
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
bool gotControlFile = false;
bool gotNcAssetFile = false;
string expectedNcAssetFileName = string.Format("{0}_{1}", ncAssetUuid, "notecard.txt");
List <string> foundPaths = new List <string>();
List <string> expectedPaths = new List <string>();
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog1));
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog2));
string filePath;
TarArchiveReader.TarEntryType tarEntryType;
while (tar.ReadEntry(out filePath, out tarEntryType) != null)
{
if (ArchiveConstants.CONTROL_FILE_PATH == filePath)
{
gotControlFile = true;
}
else if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
string fileName = filePath.Remove(0, ArchiveConstants.ASSETS_PATH.Length);
Assert.That(fileName, Is.EqualTo(expectedNcAssetFileName));
gotNcAssetFile = true;
}
else if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
foundPaths.Add(filePath);
}
}
Assert.That(gotControlFile, Is.True, "No control file in archive");
Assert.That(gotNcAssetFile, Is.True, "No notecard asset file in archive");
Assert.That(foundPaths, Is.EquivalentTo(expectedPaths));
// TODO: Test presence of more files and contents of files.
}
public void TestSaveOarNoAssets()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem {
Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid
};
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
Dictionary <string, Object> options = new Dictionary <string, Object>();
options.Add("noassets", true);
m_archiverModule.ArchiveRegion(archiveWriteStream, requestId, options);
// Don't wait for completion - with --noassets save oar happens synchronously
// Monitor.Wait(this, 60000);
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
List <string> foundPaths = new List <string>();
List <string> expectedPaths = new List <string>();
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog1));
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog2));
string filePath;
TarArchiveReader.TarEntryType tarEntryType;
byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
Dictionary <string, object> archiveOptions = new Dictionary <string, object>();
ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, Guid.Empty, archiveOptions);
arr.LoadControlFile(filePath, data, new DearchiveScenesInfo());
Assert.That(arr.ControlFileLoaded, Is.True);
while (tar.ReadEntry(out filePath, out tarEntryType) != null)
{
if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
Assert.Fail("Asset was found in saved oar of TestSaveOarNoAssets()");
}
else if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
foundPaths.Add(filePath);
}
}
Assert.That(foundPaths, Is.EquivalentTo(expectedPaths));
// TODO: Test presence of more files and contents of files.
}
public void TestSaveOar()
{
TestHelper.InMethod();
// log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid };
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
m_scene.EventManager.OnOarFileSaved += SaveCompleted;
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
lock (this)
{
m_archiverModule.ArchiveRegion(archiveWriteStream, requestId);
//AssetServerBase assetServer = (AssetServerBase)scene.CommsManager.AssetCache.AssetServer;
//while (assetServer.HasWaitingRequests())
// assetServer.ProcessNextRequest();
Monitor.Wait(this, 60000);
}
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
bool gotNcAssetFile = false;
string expectedNcAssetFileName = string.Format("{0}_{1}", ncAssetUuid, "notecard.txt");
List<string> foundPaths = new List<string>();
List<string> expectedPaths = new List<string>();
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog1));
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog2));
string filePath;
TarArchiveReader.TarEntryType tarEntryType;
byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, false, false, Guid.Empty);
arr.LoadControlFile(filePath, data);
Assert.That(arr.ControlFileLoaded, Is.True);
while (tar.ReadEntry(out filePath, out tarEntryType) != null)
{
if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
string fileName = filePath.Remove(0, ArchiveConstants.ASSETS_PATH.Length);
Assert.That(fileName, Is.EqualTo(expectedNcAssetFileName));
gotNcAssetFile = true;
}
else if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
foundPaths.Add(filePath);
}
}
Assert.That(gotNcAssetFile, Is.True, "No notecard asset file in archive");
Assert.That(foundPaths, Is.EquivalentTo(expectedPaths));
// TODO: Test presence of more files and contents of files.
}
private void tbtnSave_Click(object sender, EventArgs e)
{
bool success = false;
string message = "";
AssetNotecard n = new AssetNotecard();
n.BodyText = rtbContent.Text;
n.EmbeddedItems = new List<InventoryItem>();
if (receivedNotecard != null)
{
for (int i = 0; i < receivedNotecard.EmbeddedItems.Count; i++)
{
n.EmbeddedItems.Add(receivedNotecard.EmbeddedItems[i]);
int indexChar = 0xdc00 + i;
n.BodyText += (char)0xdbc0;
n.BodyText += (char)indexChar;
}
}
n.Encode();
UpdateStatus("Saving...");
InventoryManager.InventoryUploadedAssetCallback handler = delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
success = uploadSuccess;
if (itemID == notecard.UUID)
{
if (success)
{
UpdateStatus("OK");
notecard.AssetUUID = assetID;
}
else
{
UpdateStatus("Failed");
}
}
message = status ?? "Unknown error uploading notecard asset";
};
if (prim == null)
{
client.Inventory.RequestUploadNotecardAsset(n.AssetData, notecard.UUID, handler);
}
else
{
client.Inventory.RequestUpdateNotecardTask(n.AssetData, notecard.UUID, prim.ID, handler);
}
}
public void TestLoadPublishedOar()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem {
Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid
};
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
m_scene.EventManager.OnOarFileSaved += SaveCompleted;
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
lock (this)
{
m_archiverModule.ArchiveRegion(
archiveWriteStream, requestId, new Dictionary <string, Object>()
{
{ "wipe-owners", Boolean.TrueString }
});
Monitor.Wait(this, 60000);
}
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
{
UUID estateOwner = TestHelpers.ParseTail(0x4747);
UUID objectOwner = TestHelpers.ParseTail(0x15);
// Reload to new scene
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
SceneHelpers m_sceneHelpers2 = new SceneHelpers();
TestScene scene2 = m_sceneHelpers2.SetupScene();
SceneHelpers.SetupSceneModules(scene2, archiverModule, serialiserModule, terrainModule);
// Make sure there's a valid owner for the owner we saved (this should have been wiped if the code is
// behaving correctly
UserAccountHelpers.CreateUserWithInventory(scene2, objectOwner);
scene2.RegionInfo.EstateSettings.EstateOwner = estateOwner;
lock (this)
{
scene2.EventManager.OnOarFileLoaded += LoadCompleted;
archiverModule.DearchiveRegion(archiveReadStream);
}
Assert.That(m_lastErrorMessage, Is.Null);
SceneObjectGroup loadedSog = scene2.GetSceneObjectGroup(part1.Name);
Assert.That(loadedSog.OwnerID, Is.EqualTo(estateOwner));
Assert.That(loadedSog.LastOwnerID, Is.EqualTo(estateOwner));
}
}
/// <summary>
/// Create an asset from the given data.
/// </summary>
public static AssetBase CreateAsset(UUID assetUuid, AssetType assetType, string text, UUID creatorID)
{
AssetNotecard anc = new AssetNotecard();
anc.BodyText = text;
anc.Encode();
return CreateAsset(assetUuid, assetType, anc.AssetData, creatorID);
}
public void TestSaveOarNoAssets()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid };
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
Dictionary<string, Object> options = new Dictionary<string, Object>();
options.Add("noassets", true);
m_archiverModule.ArchiveRegion(archiveWriteStream, requestId, options);
// Don't wait for completion - with --noassets save oar happens synchronously
// Monitor.Wait(this, 60000);
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
List<string> foundPaths = new List<string>();
List<string> expectedPaths = new List<string>();
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog1));
expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog2));
string filePath;
TarArchiveReader.TarEntryType tarEntryType;
byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, Guid.Empty, archiveOptions);
arr.LoadControlFile(filePath, data, new DearchiveScenesInfo());
Assert.That(arr.ControlFileLoaded, Is.True);
while (tar.ReadEntry(out filePath, out tarEntryType) != null)
{
if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
Assert.Fail("Asset was found in saved oar of TestSaveOarNoAssets()");
}
else if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
foundPaths.Add(filePath);
}
}
Assert.That(foundPaths, Is.EquivalentTo(expectedPaths));
// TODO: Test presence of more files and contents of files.
}
void menu_on_new_note(object o, ButtonPressEventArgs args)
{
Gtk.TreeModel mod;
Gtk.TreeIter iter;
TreePath[] paths = treeview_inv.Selection.GetSelectedRows(out mod);
if(paths.Length!=1)
return;
foreach (TreePath path in paths)
{
if (mod.GetIter(out iter, path))
{
InventoryBase item = (InventoryBase)mod.GetValue(iter, 3);
if(item is InventoryFolder)
{
MainClass.client.Inventory.RequestCreateItem(item.UUID,
"New Note", "New Note", AssetType.Notecard, UUID.Random(), InventoryType.Notecard, PermissionMask.All,
delegate(bool success, InventoryItem itemx)
{
if (success) // upload the asset
{
AssetNotecard note = new AssetNotecard();
note.BodyText="Add your notes here....";
note.Encode();
MainClass.client.Inventory.RequestUploadNotecardAsset(note.AssetData, itemx.UUID,delegate (bool success2,string status,UUID item_uuid, UUID asset_uuid)
{
Gtk.TreeIter iterx;
if(success2 && assetmap.TryGetValue(item.UUID,out iterx))
{
Gdk.Pixbuf buf = getprettyicon(itemx);
Gtk.TreeIter newiter = inventory.AppendValues(iterx, buf, "New Note", itemx.UUID, itemx);
assetmap.Add(item_uuid,newiter);
treeview_inv.Selection.SelectIter(filter.ConvertChildIterToIter(newiter));
treeview_inv.ScrollToCell(inventory.GetPath(newiter), null, true, (float)0.5, (float)0.5);
treeview_inv.SetCursor(inventory.GetPath(newiter), null, true);
}
});
}
});
}
}
}
}
Process(RestBot b, Dictionary <string, string> Parameters)
{
UUID embedItemID = UUID.Zero;
string
notecardName,
notecardData;
DebugUtilities.WriteDebug("Entering key parser");
try
{
// item ID to embed is optional; handle later
if (Parameters.ContainsKey("key"))
{
UUID
.TryParse(Parameters["key"].ToString().Replace("_", " "),
out embedItemID);
}
// notecard data is required!
if (Parameters.ContainsKey("notecard"))
{
DebugUtilities
.WriteDebug("Attempting to parse notecard data from POST");
notecardData = Parameters["notecard"];
}
else
{
return("<error>notecard text data not found</error>");
}
// notecard name is optional, we'll assign a random name
if (Parameters.ContainsKey("name"))
{
DebugUtilities
.WriteDebug("Attempting to parse notecard name from POST");
notecardName = Parameters["name"];
DebugUtilities.WriteDebug("Succesfully parsed POST");
}
else
{
notecardName = "(no name)";
}
UUID
notecardItemID = UUID.Zero,
notecardAssetID = UUID.Zero;
bool
success = false,
finalUploadSuccess = false;
string message = String.Empty;
AutoResetEvent notecardEvent = new AutoResetEvent(false);
DebugUtilities
.WriteDebug($"Notecard data ('{notecardName}') found: '{notecardData}'");
#region Notecard asset data
AssetNotecard notecard = new AssetNotecard();
notecard.BodyText = notecardData;
// Item embedding
if (embedItemID != UUID.Zero)
{
// Try to fetch the inventory item
InventoryItem?item = FetchItem(b, embedItemID);
if (item != null)
{
notecard.EmbeddedItems = new List <InventoryItem> {
item
};
notecard.BodyText += (char)0xdbc0 + (char)0xdc00;
}
else
{
return("Failed to fetch inventory item " + embedItemID);
}
}
notecard.Encode();
#endregion Notecard asset data
b
.Client
.Inventory
.RequestCreateItem(b
.Client
.Inventory
.FindFolderForType(AssetType.Notecard),
notecardName,
notecardName + " created by LibreMetaverse RESTbot " + DateTime.Now,
AssetType.Notecard,
UUID.Random(),
InventoryType.Notecard,
PermissionMask.All,
delegate(bool createSuccess, InventoryItem item)
{
if (createSuccess)
{
#region Upload an empty notecard asset first
AutoResetEvent emptyNoteEvent = new AutoResetEvent(false);
AssetNotecard empty = new AssetNotecard();
empty.BodyText = "\n";
empty.Encode();
b
.Client
.Inventory
.RequestUploadNotecardAsset(empty.AssetData,
item.UUID,
delegate(
bool uploadSuccess,
string status,
UUID itemID,
UUID assetID)
{
notecardItemID = itemID;
notecardAssetID = assetID;
success = uploadSuccess;
message = status ?? "Unknown error uploading notecard asset";
emptyNoteEvent.Set();
});
emptyNoteEvent.WaitOne(NOTECARD_CREATE_TIMEOUT, false);
#endregion Upload an empty notecard asset first
if (success)
{
// Upload the actual notecard asset
b
.Client
.Inventory
.RequestUploadNotecardAsset(notecard.AssetData, item.UUID,
delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
notecardItemID = itemID;
notecardAssetID = assetID;
finalUploadSuccess = uploadSuccess;
message = status ?? "Unknown error uploading notecard asset";
notecardEvent.Set();
});
}
else
{
notecardEvent.Set();
}
}
else
{
message = "Notecard item creation failed";
notecardEvent.Set();
}
}); // end delegate // end RequestCreateItem
notecardEvent.WaitOne(NOTECARD_CREATE_TIMEOUT, false);
// DebugUtilities.WriteDebug("Notecard possibly created, ItemID " + notecardItemID + " AssetID " + notecardAssetID + " Content: '" + DownloadNotecard(b, notecardItemID, notecardAssetID) + "'");
if (finalUploadSuccess)
{
DebugUtilities
.WriteDebug($"Notecard successfully created, ItemID {notecardItemID}; AssetID {notecardAssetID}; Content: '{DownloadNotecard(b, notecardItemID, notecardAssetID)}'");
return($"<notecard><ItemID>{notecardItemID}</ItemID><AssetID>{notecardAssetID}</AssetID><name>{notecardName}</name></notecard>");
}
else
{
return($"<error>Notecard creation failed: {message}</error>");
}
} // end try
catch (Exception e)
{
DebugUtilities.WriteError(e.Message);
return($"<error>{MethodName}: {e.Message}</error>");
}
}
private void CreateTestObjects(Scene scene, out SceneObjectGroup sog1, out SceneObjectGroup sog2, out UUID ncAssetUuid)
{
SceneObjectPart part1 = CreateSceneObjectPart1();
sog1 = new SceneObjectGroup(part1);
scene.AddNewSceneObject(sog1, false);
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
ncAssetUuid = UUID.Random();
UUID ncItemUuid = UUID.Random();
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
TaskInventoryItem ncItem
= new TaskInventoryItem { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid };
SceneObjectPart part2 = CreateSceneObjectPart2();
sog2 = new SceneObjectGroup(part2);
part2.Inventory.AddInventoryItem(ncItem, true);
scene.AddNewSceneObject(sog2, false);
}
public override string Execute(string[] args, UUID fromAgentID)
{
UUID embedItemID = UUID.Zero, notecardItemID = UUID.Zero, notecardAssetID = UUID.Zero;
string filename, fileData;
bool success = false, finalUploadSuccess = false;
string message = String.Empty;
AutoResetEvent notecardEvent = new AutoResetEvent(false);
if (args.Length == 1)
{
filename = args[0];
}
else if (args.Length == 2)
{
filename = args[0];
UUID.TryParse(args[1], out embedItemID);
}
else
{
return "Usage: createnotecard filename.txt";
}
if (!File.Exists(filename))
return "File \"" + filename + "\" does not exist";
try { fileData = File.ReadAllText(filename); }
catch (Exception ex) { return "Failed to open " + filename + ": " + ex.Message; }
#region Notecard asset data
AssetNotecard notecard = new AssetNotecard();
notecard.BodyText = fileData;
// Item embedding
if (embedItemID != UUID.Zero)
{
// Try to fetch the inventory item
InventoryItem item = FetchItem(embedItemID);
if (item != null)
{
notecard.EmbeddedItems = new List<InventoryItem> { item };
notecard.BodyText += (char)0xdbc0 + (char)0xdc00;
}
else
{
return "Failed to fetch inventory item " + embedItemID;
}
}
notecard.Encode();
#endregion Notecard asset data
Client.Inventory.RequestCreateItem(Client.Inventory.FindFolderForType(AssetType.Notecard),
filename, filename + " created by OpenMetaverse TestClient " + DateTime.Now, AssetType.Notecard,
UUID.Random(), InventoryType.Notecard, PermissionMask.All,
delegate(bool createSuccess, InventoryItem item)
{
if (createSuccess)
{
#region Upload an empty notecard asset first
AutoResetEvent emptyNoteEvent = new AutoResetEvent(false);
AssetNotecard empty = new AssetNotecard();
empty.BodyText = "\n";
empty.Encode();
Client.Inventory.RequestUploadNotecardAsset(empty.AssetData, item.UUID,
delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
notecardItemID = itemID;
notecardAssetID = assetID;
success = uploadSuccess;
message = status ?? "Unknown error uploading notecard asset";
emptyNoteEvent.Set();
});
emptyNoteEvent.WaitOne(NOTECARD_CREATE_TIMEOUT, false);
#endregion Upload an empty notecard asset first
if (success)
{
// Upload the actual notecard asset
Client.Inventory.RequestUploadNotecardAsset(notecard.AssetData, item.UUID,
delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
notecardItemID = itemID;
notecardAssetID = assetID;
finalUploadSuccess = uploadSuccess;
message = status ?? "Unknown error uploading notecard asset";
notecardEvent.Set();
});
}
else
{
notecardEvent.Set();
}
}
else
{
message = "Notecard item creation failed";
notecardEvent.Set();
}
}
);
notecardEvent.WaitOne(NOTECARD_CREATE_TIMEOUT, false);
if (finalUploadSuccess)
{
Logger.Log("Notecard successfully created, ItemID " + notecardItemID + " AssetID " + notecardAssetID, Helpers.LogLevel.Info);
return DownloadNotecard(notecardItemID, notecardAssetID);
}
else
return "Notecard creation failed: " + message;
}
public void TestLoadPublishedOar()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid };
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
m_scene.EventManager.OnOarFileSaved += SaveCompleted;
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
lock (this)
{
m_archiverModule.ArchiveRegion(
archiveWriteStream, requestId, new Dictionary<string, Object>() { { "wipe-owners", Boolean.TrueString } });
Monitor.Wait(this, 60000);
}
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
{
UUID estateOwner = TestHelpers.ParseTail(0x4747);
UUID objectOwner = TestHelpers.ParseTail(0x15);
// Reload to new scene
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
SceneHelpers m_sceneHelpers2 = new SceneHelpers();
TestScene scene2 = m_sceneHelpers2.SetupScene();
SceneHelpers.SetupSceneModules(scene2, archiverModule, serialiserModule, terrainModule);
// Make sure there's a valid owner for the owner we saved (this should have been wiped if the code is
// behaving correctly
UserAccountHelpers.CreateUserWithInventory(scene2, objectOwner);
scene2.RegionInfo.EstateSettings.EstateOwner = estateOwner;
lock (this)
{
scene2.EventManager.OnOarFileLoaded += LoadCompleted;
archiverModule.DearchiveRegion(archiveReadStream);
}
Assert.That(m_lastErrorMessage, Is.Null);
SceneObjectGroup loadedSog = scene2.GetSceneObjectGroup(part1.Name);
Assert.That(loadedSog.OwnerID, Is.EqualTo(estateOwner));
Assert.That(loadedSog.LastOwnerID, Is.EqualTo(estateOwner));
}
}
public override string Execute(string[] args, UUID fromAgentID)
{
UUID embedItemID = UUID.Zero, notecardItemID = UUID.Zero, notecardAssetID = UUID.Zero;
string filename, fileData;
bool success = false, finalUploadSuccess = false;
string message = String.Empty;
AutoResetEvent notecardEvent = new AutoResetEvent(false);
if (args.Length == 1)
{
filename = args[0];
}
else if (args.Length == 2)
{
filename = args[0];
UUID.TryParse(args[1], out embedItemID);
}
else
{
return("Usage: createnotecard filename.txt");
}
if (!File.Exists(filename))
{
return("File \"" + filename + "\" does not exist");
}
try { fileData = File.ReadAllText(filename); }
catch (Exception ex) { return("Failed to open " + filename + ": " + ex.Message); }
#region Notecard asset data
AssetNotecard notecard = new AssetNotecard();
notecard.BodyText = fileData;
// Item embedding
if (embedItemID != UUID.Zero)
{
// Try to fetch the inventory item
InventoryItem item = FetchItem(embedItemID);
if (item != null)
{
notecard.EmbeddedItems = new List <InventoryItem> {
item
};
notecard.BodyText += (char)0xdbc0 + (char)0xdc00;
}
else
{
return("Failed to fetch inventory item " + embedItemID);
}
}
notecard.Encode();
#endregion Notecard asset data
Client.Inventory.RequestCreateItem(Client.Inventory.FindFolderForType(AssetType.Notecard),
filename, filename + " created by OpenMetaverse TestClient " + DateTime.Now, AssetType.Notecard,
UUID.Random(), InventoryType.Notecard, PermissionMask.All,
delegate(bool createSuccess, InventoryItem item)
{
if (createSuccess)
{
#region Upload an empty notecard asset first
AutoResetEvent emptyNoteEvent = new AutoResetEvent(false);
AssetNotecard empty = new AssetNotecard();
empty.BodyText = "\n";
empty.Encode();
Client.Inventory.RequestUploadNotecardAsset(empty.AssetData, item.UUID,
delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
notecardItemID = itemID;
notecardAssetID = assetID;
success = uploadSuccess;
message = status ?? "Unknown error uploading notecard asset";
emptyNoteEvent.Set();
});
emptyNoteEvent.WaitOne(NOTECARD_CREATE_TIMEOUT, false);
#endregion Upload an empty notecard asset first
if (success)
{
// Upload the actual notecard asset
Client.Inventory.RequestUploadNotecardAsset(notecard.AssetData, item.UUID,
delegate(bool uploadSuccess, string status, UUID itemID, UUID assetID)
{
notecardItemID = itemID;
notecardAssetID = assetID;
finalUploadSuccess = uploadSuccess;
message = status ?? "Unknown error uploading notecard asset";
notecardEvent.Set();
});
}
else
{
notecardEvent.Set();
}
}
else
{
message = "Notecard item creation failed";
notecardEvent.Set();
}
}
);
notecardEvent.WaitOne(NOTECARD_CREATE_TIMEOUT, false);
if (finalUploadSuccess)
{
Logger.Log("Notecard successfully created, ItemID " + notecardItemID + " AssetID " + notecardAssetID, Helpers.LogLevel.Info);
return(DownloadNotecard(notecardItemID, notecardAssetID));
}
else
{
return("Notecard creation failed: " + message);
}
}