OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Converted to Linux newlines.

0.6.3-post-fixes
Mike Mazur 2009-02-16 02:25:44 +00:00
parent 617016fa68
commit 16fa7f516a
22 changed files with 5968 additions and 5968 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

534
OpenSim/Grid/AssetInventoryServer/AssetInventoryServer.cs
View File

@ -1,267 +1,267 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.ServiceProcess;
using ExtensionLoader;
using ExtensionLoader.Config;
using HttpServer;
using log4net;
using OpenSim.Framework;
namespace OpenSim.Grid.AssetInventoryServer
{
public class AssetInventoryServer : ServiceBase
{
public const string CONFIG_FILE = "AssetInventoryServer.ini";
public WebServer HttpServer;
public IniConfigSource ConfigFile;
public IAssetStorageProvider StorageProvider;
public IInventoryProvider InventoryProvider;
public IAuthenticationProvider AuthenticationProvider;
public IAuthorizationProvider AuthorizationProvider;
public IMetricsProvider MetricsProvider;
private IAssetInventoryServerPlugin frontend;
public AssetInventoryServer()
{
this.ServiceName = "OpenSimAssetInventoryServer";
}
public bool Start()
{
Logger.Log.Info("Starting Asset Server");
List<string> extensionList = null;
int port = 0;
X509Certificate2 serverCert = null;
try { ConfigFile = new IniConfigSource(CONFIG_FILE); }
catch (Exception)
{
Logger.Log.Error("Failed to load the config file " + CONFIG_FILE);
return false;
}
try
{
IConfig extensionConfig = ConfigFile.Configs["Config"];
// Load the port number to listen on
port = extensionConfig.GetInt("ListenPort");
// Load the server certificate file
string certFile = extensionConfig.GetString("SSLCertFile");
if (!String.IsNullOrEmpty(certFile))
serverCert = new X509Certificate2(certFile);
}
catch (Exception)
{
Logger.Log.Error("Failed to load [Config] section from " + CONFIG_FILE);
return false;
}
try
{
// Load the extension list (and ordering) from our config file
IConfig extensionConfig = ConfigFile.Configs["Extensions"];
extensionList = new List<string>(extensionConfig.GetKeys());
}
catch (Exception)
{
Logger.Log.Error("Failed to load [Extensions] section from " + CONFIG_FILE);
return false;
}
//try
//{
// // Create a reference list for C# extensions compiled at runtime
// List<string> references = new List<string>();
// references.Add("OpenMetaverseTypes.dll");
// references.Add("OpenMetaverse.dll");
// references.Add("OpenMetaverse.StructuredData.dll");
// references.Add("OpenMetaverse.Http.dll");
// references.Add("ExtensionLoader.dll");
// references.Add("AssetServer.exe");
// // Get a list of all of the members of AssetServer that are interfaces
// List<FieldInfo> assignables = ExtensionLoader<AssetServer>.GetInterfaces(this);
// // Load all of the extensions
// ExtensionLoader<AssetServer>.LoadAllExtensions(
// Assembly.GetExecutingAssembly(),
// Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
// extensionList,
// references,
// "AssetServer.*.dll",
// "AssetServer.*.cs",
// this,
// assignables);
//}
//catch (ExtensionException ex)
//{
// Logger.Log.Error("Interface loading failed, shutting down: " + ex.Message);
// if (ex.InnerException != null)
// Logger.Log.Error(ex.InnerException.Message, ex.InnerException);
// Stop();
// return false;
//}
StorageProvider = LoadAssetInventoryServerPlugin("/OpenSim/AssetInventoryServer/StorageProvider") as IAssetStorageProvider;
try
{
InitHttpServer(port, serverCert);
}
catch (Exception ex)
{
Logger.Log.Error("Initializing the HTTP server failed, shutting down: " + ex.Message);
Stop();
return false;
}
frontend = LoadAssetInventoryServerPlugin("/OpenSim/AssetInventoryServer/Frontend");
// Start all of the extensions
//foreach (IExtension<AssetServer> extension in ExtensionLoader<AssetServer>.Extensions)
//{
// Logger.Log.Info("Starting extension " + extension.GetType().Name);
// extension.Start(this);
//}
return true;
}
public void Shutdown()
{
foreach (IExtension<AssetInventoryServer> extension in ExtensionLoader<AssetInventoryServer>.Extensions)
{
Logger.Log.Debug("Disposing extension " + extension.GetType().Name);
try { extension.Stop(); }
catch (Exception ex)
{ Logger.Log.ErrorFormat("Failure shutting down extension {0}: {1}", extension.GetType().Name, ex.Message); }
}
if (HttpServer != null)
HttpServer.Stop();
}
void InitHttpServer(int port, X509Certificate serverCert)
{
if (serverCert != null)
HttpServer = new WebServer(IPAddress.Any, port, serverCert, null, false);
else
HttpServer = new WebServer(IPAddress.Any, port);
HttpServer.LogWriter = new log4netLogWriter(Logger.Log);
HttpServer.Set404Handler(
delegate(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
Logger.Log.Warn("Requested page was not found: " + request.Uri.PathAndQuery);
string notFoundString = "<html><head><title>Page Not Found</title></head><body>The requested page or method was not found</body></html>";
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(notFoundString);
response.Body.Write(buffer, 0, buffer.Length);
response.Status = HttpStatusCode.NotFound;
return true;
}
);
HttpServer.Start();
Logger.Log.Info("Asset server is listening on port " + port);
}
#region ServiceBase Overrides
protected override void OnStart(string[] args)
{
Start();
}
protected override void OnStop()
{
Shutdown();
}
#endregion
private IAssetInventoryServerPlugin LoadAssetInventoryServerPlugin(string addinPath)
{
PluginLoader<IAssetInventoryServerPlugin> loader = new PluginLoader<IAssetInventoryServerPlugin>(new AssetInventoryServerPluginInitialiser(this));
//loader.Add ("/OpenSim/AssetInventoryServer/StorageProvider", new PluginProviderFilter (provider));
//loader.Add("/OpenSim/AssetInventoryServer/StorageProvider", new PluginCountConstraint(1));
loader.Add(addinPath);
loader.Load();
return loader.Plugin;
}
}
public class log4netLogWriter : ILogWriter
{
ILog Log;
public log4netLogWriter(ILog log)
{
Log = log;
}
public void Write(object source, LogPrio prio, string message)
{
switch (prio)
{
case LogPrio.Trace:
case LogPrio.Debug:
Log.DebugFormat("{0}: {1}", source, message);
break;
case LogPrio.Info:
Log.InfoFormat("{0}: {1}", source, message);
break;
case LogPrio.Warning:
Log.WarnFormat("{0}: {1}", source, message);
break;
case LogPrio.Error:
Log.ErrorFormat("{0}: {1}", source, message);
break;
case LogPrio.Fatal:
Log.FatalFormat("{0}: {1}", source, message);
break;
}
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.ServiceProcess;
using ExtensionLoader;
using ExtensionLoader.Config;
using HttpServer;
using log4net;
using OpenSim.Framework;
namespace OpenSim.Grid.AssetInventoryServer
{
public class AssetInventoryServer : ServiceBase
{
public const string CONFIG_FILE = "AssetInventoryServer.ini";
public WebServer HttpServer;
public IniConfigSource ConfigFile;
public IAssetStorageProvider StorageProvider;
public IInventoryProvider InventoryProvider;
public IAuthenticationProvider AuthenticationProvider;
public IAuthorizationProvider AuthorizationProvider;
public IMetricsProvider MetricsProvider;
private IAssetInventoryServerPlugin frontend;
public AssetInventoryServer()
{
this.ServiceName = "OpenSimAssetInventoryServer";
}
public bool Start()
{
Logger.Log.Info("Starting Asset Server");
List<string> extensionList = null;
int port = 0;
X509Certificate2 serverCert = null;
try { ConfigFile = new IniConfigSource(CONFIG_FILE); }
catch (Exception)
{
Logger.Log.Error("Failed to load the config file " + CONFIG_FILE);
return false;
}
try
{
IConfig extensionConfig = ConfigFile.Configs["Config"];
// Load the port number to listen on
port = extensionConfig.GetInt("ListenPort");
// Load the server certificate file
string certFile = extensionConfig.GetString("SSLCertFile");
if (!String.IsNullOrEmpty(certFile))
serverCert = new X509Certificate2(certFile);
}
catch (Exception)
{
Logger.Log.Error("Failed to load [Config] section from " + CONFIG_FILE);
return false;
}
try
{
// Load the extension list (and ordering) from our config file
IConfig extensionConfig = ConfigFile.Configs["Extensions"];
extensionList = new List<string>(extensionConfig.GetKeys());
}
catch (Exception)
{
Logger.Log.Error("Failed to load [Extensions] section from " + CONFIG_FILE);
return false;
}
//try
//{
// // Create a reference list for C# extensions compiled at runtime
// List<string> references = new List<string>();
// references.Add("OpenMetaverseTypes.dll");
// references.Add("OpenMetaverse.dll");
// references.Add("OpenMetaverse.StructuredData.dll");
// references.Add("OpenMetaverse.Http.dll");
// references.Add("ExtensionLoader.dll");
// references.Add("AssetServer.exe");
// // Get a list of all of the members of AssetServer that are interfaces
// List<FieldInfo> assignables = ExtensionLoader<AssetServer>.GetInterfaces(this);
// // Load all of the extensions
// ExtensionLoader<AssetServer>.LoadAllExtensions(
// Assembly.GetExecutingAssembly(),
// Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
// extensionList,
// references,
// "AssetServer.*.dll",
// "AssetServer.*.cs",
// this,
// assignables);
//}
//catch (ExtensionException ex)
//{
// Logger.Log.Error("Interface loading failed, shutting down: " + ex.Message);
// if (ex.InnerException != null)
// Logger.Log.Error(ex.InnerException.Message, ex.InnerException);
// Stop();
// return false;
//}
StorageProvider = LoadAssetInventoryServerPlugin("/OpenSim/AssetInventoryServer/StorageProvider") as IAssetStorageProvider;
try
{
InitHttpServer(port, serverCert);
}
catch (Exception ex)
{
Logger.Log.Error("Initializing the HTTP server failed, shutting down: " + ex.Message);
Stop();
return false;
}
frontend = LoadAssetInventoryServerPlugin("/OpenSim/AssetInventoryServer/Frontend");
// Start all of the extensions
//foreach (IExtension<AssetServer> extension in ExtensionLoader<AssetServer>.Extensions)
//{
// Logger.Log.Info("Starting extension " + extension.GetType().Name);
// extension.Start(this);
//}
return true;
}
public void Shutdown()
{
foreach (IExtension<AssetInventoryServer> extension in ExtensionLoader<AssetInventoryServer>.Extensions)
{
Logger.Log.Debug("Disposing extension " + extension.GetType().Name);
try { extension.Stop(); }
catch (Exception ex)
{ Logger.Log.ErrorFormat("Failure shutting down extension {0}: {1}", extension.GetType().Name, ex.Message); }
}
if (HttpServer != null)
HttpServer.Stop();
}
void InitHttpServer(int port, X509Certificate serverCert)
{
if (serverCert != null)
HttpServer = new WebServer(IPAddress.Any, port, serverCert, null, false);
else
HttpServer = new WebServer(IPAddress.Any, port);
HttpServer.LogWriter = new log4netLogWriter(Logger.Log);
HttpServer.Set404Handler(
delegate(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
Logger.Log.Warn("Requested page was not found: " + request.Uri.PathAndQuery);
string notFoundString = "<html><head><title>Page Not Found</title></head><body>The requested page or method was not found</body></html>";
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(notFoundString);
response.Body.Write(buffer, 0, buffer.Length);
response.Status = HttpStatusCode.NotFound;
return true;
}
);
HttpServer.Start();
Logger.Log.Info("Asset server is listening on port " + port);
}
#region ServiceBase Overrides
protected override void OnStart(string[] args)
{
Start();
}
protected override void OnStop()
{
Shutdown();
}
#endregion
private IAssetInventoryServerPlugin LoadAssetInventoryServerPlugin(string addinPath)
{
PluginLoader<IAssetInventoryServerPlugin> loader = new PluginLoader<IAssetInventoryServerPlugin>(new AssetInventoryServerPluginInitialiser(this));
//loader.Add ("/OpenSim/AssetInventoryServer/StorageProvider", new PluginProviderFilter (provider));
//loader.Add("/OpenSim/AssetInventoryServer/StorageProvider", new PluginCountConstraint(1));
loader.Add(addinPath);
loader.Load();
return loader.Plugin;
}
}
public class log4netLogWriter : ILogWriter
{
ILog Log;
public log4netLogWriter(ILog log)
{
Log = log;
}
public void Write(object source, LogPrio prio, string message)
{
switch (prio)
{
case LogPrio.Trace:
case LogPrio.Debug:
Log.DebugFormat("{0}: {1}", source, message);
break;
case LogPrio.Info:
Log.InfoFormat("{0}: {1}", source, message);
break;
case LogPrio.Warning:
Log.WarnFormat("{0}: {1}", source, message);
break;
case LogPrio.Error:
Log.ErrorFormat("{0}: {1}", source, message);
break;
case LogPrio.Fatal:
Log.FatalFormat("{0}: {1}", source, message);
break;
}
}
}
}

156
OpenSim/Grid/AssetInventoryServer/Extensions/AuthorizeAll.cs
View File

@ -1,78 +1,78 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using ExtensionLoader;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class AuthorizeAll : IExtension<AssetInventoryServer>, IAuthorizationProvider
{
AssetInventoryServer server;
public AuthorizeAll()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
}
public void Stop()
{
}
public bool IsMetadataAuthorized(UUID authToken, UUID assetID)
{
return true;
}
public bool IsDataAuthorized(UUID authToken, UUID assetID)
{
return true;
}
public bool IsCreateAuthorized(UUID authToken)
{
return true;
}
public bool IsInventoryReadAuthorized(UUID authToken, Uri owner)
{
return true;
}
public bool IsInventoryWriteAuthorized(UUID authToken, Uri owner)
{
return true;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using ExtensionLoader;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class AuthorizeAll : IExtension<AssetInventoryServer>, IAuthorizationProvider
{
AssetInventoryServer server;
public AuthorizeAll()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
}
public void Stop()
{
}
public bool IsMetadataAuthorized(UUID authToken, UUID assetID)
{
return true;
}
public bool IsDataAuthorized(UUID authToken, UUID assetID)
{
return true;
}
public bool IsCreateAuthorized(UUID authToken)
{
return true;
}
public bool IsInventoryReadAuthorized(UUID authToken, Uri owner)
{
return true;
}
public bool IsInventoryWriteAuthorized(UUID authToken, Uri owner)
{
return true;
}
}
}

250
OpenSim/Grid/AssetInventoryServer/Extensions/BrowseFrontend.cs
View File

@ -1,125 +1,125 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Net;
using System.Text;
using System.Web;
using ExtensionLoader;
using OpenMetaverse;
using HttpServer;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class BrowseFrontend : IExtension<AssetInventoryServer>
{
AssetInventoryServer server;
public BrowseFrontend()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
// Request for / or /?...
server.HttpServer.AddHandler("get", null, @"(^/$)|(^/\?.*)", BrowseRequestHandler);
}
public void Stop()
{
}
bool BrowseRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
const int ASSETS_PER_PAGE = 25;
const string HEADER = "<html><head><title>Asset Server</title></head><body>";
const string TABLE_HEADER =
"<table><tr><th>Name</th><th>Description</th><th>Type</th><th>ID</th><th>Temporary</th><th>SHA-1</th></tr>";
const string TABLE_FOOTER = "</table>";
const string FOOTER = "</body></html>";
UUID authToken = Utils.GetAuthToken(request);
StringBuilder html = new StringBuilder();
int start = 0;
uint page = 0;
if (!String.IsNullOrEmpty(request.Uri.Query))
{
NameValueCollection query = HttpUtility.ParseQueryString(request.Uri.Query);
if (!String.IsNullOrEmpty(query["page"]) && UInt32.TryParse(query["page"], out page))
start = (int)page * ASSETS_PER_PAGE;
}
html.AppendLine(HEADER);
html.AppendLine("<p>");
if (page > 0)
html.AppendFormat("<a href=\"{0}?page={1}\">&lt; Previous Page</a> | ", request.Uri.AbsolutePath, page - 1);
html.AppendFormat("<a href=\"{0}?page={1}\">Next Page &gt;</a>", request.Uri.AbsolutePath, page + 1);
html.AppendLine("</p>");
html.AppendLine(TABLE_HEADER);
server.StorageProvider.ForEach(
delegate(Metadata data)
{
if (server.AuthorizationProvider.IsMetadataAuthorized(authToken, data.ID))
{
html.AppendLine(String.Format(
"<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td></tr>",
data.Name, data.Description, data.ContentType, data.ID, data.Temporary,
BitConverter.ToString(data.SHA1).Replace("-", String.Empty)));
}
else
{
html.AppendLine(String.Format(
"<tr><td>[Protected Asset]</td><td>&nbsp;</td><td>&nbsp;</td><td>{0}</td><td>{1}</td><td>&nbsp;</td></tr>",
data.ID, data.Temporary));
}
}, start, ASSETS_PER_PAGE
);
html.AppendLine(TABLE_FOOTER);
html.AppendLine(FOOTER);
byte[] responseData = System.Text.Encoding.UTF8.GetBytes(html.ToString());
response.Status = HttpStatusCode.OK;
response.Body.Write(responseData, 0, responseData.Length);
response.Body.Flush();
return true;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Net;
using System.Text;
using System.Web;
using ExtensionLoader;
using OpenMetaverse;
using HttpServer;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class BrowseFrontend : IExtension<AssetInventoryServer>
{
AssetInventoryServer server;
public BrowseFrontend()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
// Request for / or /?...
server.HttpServer.AddHandler("get", null, @"(^/$)|(^/\?.*)", BrowseRequestHandler);
}
public void Stop()
{
}
bool BrowseRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
const int ASSETS_PER_PAGE = 25;
const string HEADER = "<html><head><title>Asset Server</title></head><body>";
const string TABLE_HEADER =
"<table><tr><th>Name</th><th>Description</th><th>Type</th><th>ID</th><th>Temporary</th><th>SHA-1</th></tr>";
const string TABLE_FOOTER = "</table>";
const string FOOTER = "</body></html>";
UUID authToken = Utils.GetAuthToken(request);
StringBuilder html = new StringBuilder();
int start = 0;
uint page = 0;
if (!String.IsNullOrEmpty(request.Uri.Query))
{
NameValueCollection query = HttpUtility.ParseQueryString(request.Uri.Query);
if (!String.IsNullOrEmpty(query["page"]) && UInt32.TryParse(query["page"], out page))
start = (int)page * ASSETS_PER_PAGE;
}
html.AppendLine(HEADER);
html.AppendLine("<p>");
if (page > 0)
html.AppendFormat("<a href=\"{0}?page={1}\">&lt; Previous Page</a> | ", request.Uri.AbsolutePath, page - 1);
html.AppendFormat("<a href=\"{0}?page={1}\">Next Page &gt;</a>", request.Uri.AbsolutePath, page + 1);
html.AppendLine("</p>");
html.AppendLine(TABLE_HEADER);
server.StorageProvider.ForEach(
delegate(Metadata data)
{
if (server.AuthorizationProvider.IsMetadataAuthorized(authToken, data.ID))
{
html.AppendLine(String.Format(
"<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td></tr>",
data.Name, data.Description, data.ContentType, data.ID, data.Temporary,
BitConverter.ToString(data.SHA1).Replace("-", String.Empty)));
}
else
{
html.AppendLine(String.Format(
"<tr><td>[Protected Asset]</td><td>&nbsp;</td><td>&nbsp;</td><td>{0}</td><td>{1}</td><td>&nbsp;</td></tr>",
data.ID, data.Temporary));
}
}, start, ASSETS_PER_PAGE
);
html.AppendLine(TABLE_FOOTER);
html.AppendLine(FOOTER);
byte[] responseData = System.Text.Encoding.UTF8.GetBytes(html.ToString());
response.Status = HttpStatusCode.OK;
response.Body.Write(responseData, 0, responseData.Length);
response.Body.Flush();
return true;
}
}
}

156
OpenSim/Grid/AssetInventoryServer/Extensions/DBConnString.cs
View File

@ -1,78 +1,78 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Xml;
using ExtensionLoader.Config;
using MySql.Data.MySqlClient;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public static class DBConnString
{
private static string connectionString;
/// <summary>
/// Parses the MySQL connection string out of either the asset server
/// .ini or a OpenSim-style .xml file and caches the result for future
/// requests
/// </summary>
public static string GetConnectionString(IniConfigSource configFile)
{
if (connectionString == null)
{
// Try parsing from the ini file
try
{
// Load the extension list (and ordering) from our config file
IConfig extensionConfig = configFile.Configs["MySQL"];
connectionString = extensionConfig.GetString("database_connect", null);
}
catch (Exception) { }
if (connectionString != null)
{
// Force MySQL's broken connection pooling off
MySqlConnectionStringBuilder builder = new MySqlConnectionStringBuilder(connectionString);
builder.Pooling = false;
if (String.IsNullOrEmpty(builder.Database))
Logger.Log.Error("No database selected in the connectionString: " + connectionString);
connectionString = builder.ToString();
}
else
{
Logger.Log.Error("Database connection string is missing, check that the database_connect line is " +
"correct and uncommented in AssetInventoryServer.ini");
}
}
return connectionString;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Xml;
using ExtensionLoader.Config;
using MySql.Data.MySqlClient;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public static class DBConnString
{
private static string connectionString;
/// <summary>
/// Parses the MySQL connection string out of either the asset server
/// .ini or a OpenSim-style .xml file and caches the result for future
/// requests
/// </summary>
public static string GetConnectionString(IniConfigSource configFile)
{
if (connectionString == null)
{
// Try parsing from the ini file
try
{
// Load the extension list (and ordering) from our config file
IConfig extensionConfig = configFile.Configs["MySQL"];
connectionString = extensionConfig.GetString("database_connect", null);
}
catch (Exception) { }
if (connectionString != null)
{
// Force MySQL's broken connection pooling off
MySqlConnectionStringBuilder builder = new MySqlConnectionStringBuilder(connectionString);
builder.Pooling = false;
if (String.IsNullOrEmpty(builder.Database))
Logger.Log.Error("No database selected in the connectionString: " + connectionString);
connectionString = builder.ToString();
}
else
{
Logger.Log.Error("Database connection string is missing, check that the database_connect line is " +
"correct and uncommented in AssetInventoryServer.ini");
}
}
return connectionString;
}
}
}

136
OpenSim/Grid/AssetInventoryServer/Extensions/NullAuthentication.cs
View File

@ -1,68 +1,68 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using ExtensionLoader;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class NullAuthentication : IExtension<AssetInventoryServer>, IAuthenticationProvider
{
AssetInventoryServer server;
public NullAuthentication()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
}
public void Stop()
{
}
public void AddIdentifier(UUID authToken, Uri identifier)
{
}
public bool RemoveIdentifier(UUID authToken)
{
return true;
}
public bool TryGetIdentifier(UUID authToken, out Uri identifier)
{
identifier = null;
return true;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using ExtensionLoader;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class NullAuthentication : IExtension<AssetInventoryServer>, IAuthenticationProvider
{
AssetInventoryServer server;
public NullAuthentication()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
}
public void Stop()
{
}
public void AddIdentifier(UUID authToken, Uri identifier)
{
}
public bool RemoveIdentifier(UUID authToken)
{
return true;
}
public bool TryGetIdentifier(UUID authToken, out Uri identifier)
{
identifier = null;
return true;
}
}
}

248
OpenSim/Grid/AssetInventoryServer/Extensions/NullMetrics.cs
View File

@ -1,124 +1,124 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using ExtensionLoader;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class NullMetrics : IExtension<AssetInventoryServer>, IMetricsProvider
{
AssetInventoryServer server;
public NullMetrics()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
}
public void Stop()
{
}
public void LogAssetMetadataFetch(string extension, BackendResponse response, UUID assetID, DateTime time)
{
Logger.Log.DebugFormat("[{0}] AssetMetadataFetch(): AssetID: {1}, Response: {2}", extension, assetID, response);
}
public void LogAssetDataFetch(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time)
{
Logger.Log.DebugFormat("[{0}] AssetDataFetch(): AssetID: {1}, DataSize: {2}, Response: {3}", extension, assetID,
dataSize, response);
}
public void LogAssetCreate(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time)
{
Logger.Log.DebugFormat("[{0}] AssetCreate(): AssetID: {1}, DataSize: {2}, Response: {3}", extension, assetID,
dataSize, response);
}
public void LogInventoryFetch(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetch(): ObjID: {1}, Folder: {2}, OwnerID: {3}, Response: {4}", extension,
objID, folder, owner, response);
}
public void LogInventoryFetchFolderContents(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchFolderContents(): FolderID: {1}, OwnerID: {2}, Response: {3}", extension,
folderID, owner, response);
}
public void LogInventoryFetchFolderList(string extension, BackendResponse response, Uri owner, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchFolderList(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryFetchInventory(string extension, BackendResponse response, Uri owner, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchInventory(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryFetchActiveGestures(string extension, BackendResponse response, Uri owner, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchActiveGestures(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryCreate(string extension, BackendResponse response, Uri owner, bool folder, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryCreate(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryCreateInventory(string extension, BackendResponse response, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryCreateInventory(): Response: {1}", extension,
response);
}
public void LogInventoryDelete(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryDelete(): OwnerID: {1}, Folder: {2}, Response: {3}", extension,
owner, folder, response);
}
public void LogInventoryPurgeFolder(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryPurgeFolder(): OwnerID: {1}, FolderID: {2}, Response: {3}", extension,
owner, response);
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using ExtensionLoader;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class NullMetrics : IExtension<AssetInventoryServer>, IMetricsProvider
{
AssetInventoryServer server;
public NullMetrics()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
}
public void Stop()
{
}
public void LogAssetMetadataFetch(string extension, BackendResponse response, UUID assetID, DateTime time)
{
Logger.Log.DebugFormat("[{0}] AssetMetadataFetch(): AssetID: {1}, Response: {2}", extension, assetID, response);
}
public void LogAssetDataFetch(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time)
{
Logger.Log.DebugFormat("[{0}] AssetDataFetch(): AssetID: {1}, DataSize: {2}, Response: {3}", extension, assetID,
dataSize, response);
}
public void LogAssetCreate(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time)
{
Logger.Log.DebugFormat("[{0}] AssetCreate(): AssetID: {1}, DataSize: {2}, Response: {3}", extension, assetID,
dataSize, response);
}
public void LogInventoryFetch(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetch(): ObjID: {1}, Folder: {2}, OwnerID: {3}, Response: {4}", extension,
objID, folder, owner, response);
}
public void LogInventoryFetchFolderContents(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchFolderContents(): FolderID: {1}, OwnerID: {2}, Response: {3}", extension,
folderID, owner, response);
}
public void LogInventoryFetchFolderList(string extension, BackendResponse response, Uri owner, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchFolderList(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryFetchInventory(string extension, BackendResponse response, Uri owner, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchInventory(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryFetchActiveGestures(string extension, BackendResponse response, Uri owner, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryFetchActiveGestures(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryCreate(string extension, BackendResponse response, Uri owner, bool folder, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryCreate(): OwnerID: {1}, Response: {2}", extension,
owner, response);
}
public void LogInventoryCreateInventory(string extension, BackendResponse response, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryCreateInventory(): Response: {1}", extension,
response);
}
public void LogInventoryDelete(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryDelete(): OwnerID: {1}, Folder: {2}, Response: {3}", extension,
owner, folder, response);
}
public void LogInventoryPurgeFolder(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time)
{
Logger.Log.DebugFormat("[{0}] InventoryPurgeFolder(): OwnerID: {1}, FolderID: {2}, Response: {3}", extension,
owner, response);
}
}
}

430
OpenSim/Grid/AssetInventoryServer/Extensions/OpenSimFrontend.cs
View File

@ -1,215 +1,215 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Xml;
using ExtensionLoader;
using OpenMetaverse;
using HttpServer;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class OpenSimFrontend : IExtension<AssetInventoryServer>
{
AssetInventoryServer server;
public OpenSimFrontend()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
// Asset request
server.HttpServer.AddHandler("get", null, @"^/assets/", AssetRequestHandler);
// Asset creation
server.HttpServer.AddHandler("post", null, @"^/assets/", AssetPostHandler);
}
public void Stop()
{
}
bool AssetRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up to get the asset ID out
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && rawUrl[2].Length >= 36 && UUID.TryParse(rawUrl[2].Substring(0, 36), out assetID))
{
Metadata metadata;
byte[] assetData;
BackendResponse dataResponse;
if ((dataResponse = server.StorageProvider.TryFetchDataMetadata(assetID, out metadata, out assetData)) == BackendResponse.Success)
{
MemoryStream stream = new MemoryStream();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create(stream, settings);
writer.WriteStartDocument();
writer.WriteStartElement("AssetBase");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
writer.WriteStartElement("FullID");
writer.WriteStartElement("Guid");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteStartElement("ID");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Data");
writer.WriteBase64(assetData, 0, assetData.Length);
writer.WriteEndElement();
writer.WriteStartElement("Type");
writer.WriteValue(Utils.ContentTypeToSLAssetType(metadata.ContentType));
writer.WriteEndElement();
writer.WriteStartElement("Name");
writer.WriteString(metadata.Name);
writer.WriteEndElement();
writer.WriteStartElement("Description");
writer.WriteString(metadata.Description);
writer.WriteEndElement();
writer.WriteStartElement("Local");
writer.WriteValue(false);
writer.WriteEndElement();
writer.WriteStartElement("Temporary");
writer.WriteValue(metadata.Temporary);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
byte[] buffer = stream.GetBuffer();
response.Status = HttpStatusCode.OK;
response.ContentType = "application/xml";
response.ContentLength = stream.Length;
response.Body.Write(buffer, 0, (int)stream.Length);
response.Body.Flush();
}
else
{
Logger.Log.WarnFormat("Failed to fetch asset data or metadata for {0}: {1}", assetID, dataResponse);
response.Status = HttpStatusCode.NotFound;
}
}
else
{
Logger.Log.Warn("Unrecognized OpenSim asset request: " + request.Uri.PathAndQuery);
}
return true;
}
bool AssetPostHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = null;
Metadata metadata = new Metadata();
Logger.Log.Debug("Handling OpenSim asset upload");
try
{
using (XmlReader reader = XmlReader.Create(request.Body))
{
reader.MoveToContent();
reader.ReadStartElement("AssetBase");
reader.ReadStartElement("FullID");
UUID.TryParse(reader.ReadElementContentAsString("Guid", String.Empty), out metadata.ID);
reader.ReadEndElement();
reader.ReadStartElement("ID");
reader.Skip();
reader.ReadEndElement();
// HACK: Broken on Mono. https://bugzilla.novell.com/show_bug.cgi?id=464229
//int readBytes = 0;
//byte[] buffer = new byte[1024];
//MemoryStream stream = new MemoryStream();
//BinaryWriter writer = new BinaryWriter(stream);
//while ((readBytes = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length)) > 0)
// writer.Write(buffer, 0, readBytes);
//writer.Flush();
//assetData = stream.GetBuffer();
//Array.Resize<byte>(ref assetData, (int)stream.Length);
assetData = Convert.FromBase64String(reader.ReadElementContentAsString());
int type;
Int32.TryParse(reader.ReadElementContentAsString("Type", String.Empty), out type);
metadata.ContentType = Utils.SLAssetTypeToContentType(type);
metadata.Name = reader.ReadElementContentAsString("Name", String.Empty);
metadata.Description = reader.ReadElementContentAsString("Description", String.Empty);
Boolean.TryParse(reader.ReadElementContentAsString("Local", String.Empty), out metadata.Temporary);
Boolean.TryParse(reader.ReadElementContentAsString("Temporary", String.Empty), out metadata.Temporary);
reader.ReadEndElement();
}
if (assetData != null && assetData.Length > 0)
{
metadata.SHA1 = OpenMetaverse.Utils.SHA1(assetData);
metadata.CreationDate = DateTime.Now;
BackendResponse storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData);
if (storageResponse == BackendResponse.Success)
response.Status = HttpStatusCode.Created;
else if (storageResponse == BackendResponse.NotFound)
response.Status = HttpStatusCode.NotFound;
else
response.Status = HttpStatusCode.InternalServerError;
}
else
{
Logger.Log.Warn("AssetPostHandler called with no asset data");
response.Status = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
Logger.Log.Warn("Failed to parse POST data (expecting AssetBase): " + ex.Message);
response.Status = HttpStatusCode.BadRequest;
}
Logger.Log.Debug("Finished handling OpenSim asset upload, Status: " + response.Status.ToString());
return true;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Xml;
using ExtensionLoader;
using OpenMetaverse;
using HttpServer;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class OpenSimFrontend : IExtension<AssetInventoryServer>
{
AssetInventoryServer server;
public OpenSimFrontend()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
// Asset request
server.HttpServer.AddHandler("get", null, @"^/assets/", AssetRequestHandler);
// Asset creation
server.HttpServer.AddHandler("post", null, @"^/assets/", AssetPostHandler);
}
public void Stop()
{
}
bool AssetRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up to get the asset ID out
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && rawUrl[2].Length >= 36 && UUID.TryParse(rawUrl[2].Substring(0, 36), out assetID))
{
Metadata metadata;
byte[] assetData;
BackendResponse dataResponse;
if ((dataResponse = server.StorageProvider.TryFetchDataMetadata(assetID, out metadata, out assetData)) == BackendResponse.Success)
{
MemoryStream stream = new MemoryStream();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create(stream, settings);
writer.WriteStartDocument();
writer.WriteStartElement("AssetBase");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
writer.WriteStartElement("FullID");
writer.WriteStartElement("Guid");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteStartElement("ID");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Data");
writer.WriteBase64(assetData, 0, assetData.Length);
writer.WriteEndElement();
writer.WriteStartElement("Type");
writer.WriteValue(Utils.ContentTypeToSLAssetType(metadata.ContentType));
writer.WriteEndElement();
writer.WriteStartElement("Name");
writer.WriteString(metadata.Name);
writer.WriteEndElement();
writer.WriteStartElement("Description");
writer.WriteString(metadata.Description);
writer.WriteEndElement();
writer.WriteStartElement("Local");
writer.WriteValue(false);
writer.WriteEndElement();
writer.WriteStartElement("Temporary");
writer.WriteValue(metadata.Temporary);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
byte[] buffer = stream.GetBuffer();
response.Status = HttpStatusCode.OK;
response.ContentType = "application/xml";
response.ContentLength = stream.Length;
response.Body.Write(buffer, 0, (int)stream.Length);
response.Body.Flush();
}
else
{
Logger.Log.WarnFormat("Failed to fetch asset data or metadata for {0}: {1}", assetID, dataResponse);
response.Status = HttpStatusCode.NotFound;
}
}
else
{
Logger.Log.Warn("Unrecognized OpenSim asset request: " + request.Uri.PathAndQuery);
}
return true;
}
bool AssetPostHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = null;
Metadata metadata = new Metadata();
Logger.Log.Debug("Handling OpenSim asset upload");
try
{
using (XmlReader reader = XmlReader.Create(request.Body))
{
reader.MoveToContent();
reader.ReadStartElement("AssetBase");
reader.ReadStartElement("FullID");
UUID.TryParse(reader.ReadElementContentAsString("Guid", String.Empty), out metadata.ID);
reader.ReadEndElement();
reader.ReadStartElement("ID");
reader.Skip();
reader.ReadEndElement();
// HACK: Broken on Mono. https://bugzilla.novell.com/show_bug.cgi?id=464229
//int readBytes = 0;
//byte[] buffer = new byte[1024];
//MemoryStream stream = new MemoryStream();
//BinaryWriter writer = new BinaryWriter(stream);
//while ((readBytes = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length)) > 0)
// writer.Write(buffer, 0, readBytes);
//writer.Flush();
//assetData = stream.GetBuffer();
//Array.Resize<byte>(ref assetData, (int)stream.Length);
assetData = Convert.FromBase64String(reader.ReadElementContentAsString());
int type;
Int32.TryParse(reader.ReadElementContentAsString("Type", String.Empty), out type);
metadata.ContentType = Utils.SLAssetTypeToContentType(type);
metadata.Name = reader.ReadElementContentAsString("Name", String.Empty);
metadata.Description = reader.ReadElementContentAsString("Description", String.Empty);
Boolean.TryParse(reader.ReadElementContentAsString("Local", String.Empty), out metadata.Temporary);
Boolean.TryParse(reader.ReadElementContentAsString("Temporary", String.Empty), out metadata.Temporary);
reader.ReadEndElement();
}
if (assetData != null && assetData.Length > 0)
{
metadata.SHA1 = OpenMetaverse.Utils.SHA1(assetData);
metadata.CreationDate = DateTime.Now;
BackendResponse storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData);
if (storageResponse == BackendResponse.Success)
response.Status = HttpStatusCode.Created;
else if (storageResponse == BackendResponse.NotFound)
response.Status = HttpStatusCode.NotFound;
else
response.Status = HttpStatusCode.InternalServerError;
}
else
{
Logger.Log.Warn("AssetPostHandler called with no asset data");
response.Status = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
Logger.Log.Warn("Failed to parse POST data (expecting AssetBase): " + ex.Message);
response.Status = HttpStatusCode.BadRequest;
}
Logger.Log.Debug("Finished handling OpenSim asset upload, Status: " + response.Status.ToString());
return true;
}
}
}

1272
OpenSim/Grid/AssetInventoryServer/Extensions/OpenSimInventoryFrontend.cs
View File

File diff suppressed because it is too large Load Diff

1608
OpenSim/Grid/AssetInventoryServer/Extensions/OpenSimMySQLInventory.cs
View File

File diff suppressed because it is too large Load Diff

622
OpenSim/Grid/AssetInventoryServer/Extensions/OpenSimMySQLStorage.cs
View File

@ -1,311 +1,311 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Data;
using MySql.Data.MySqlClient;
using ExtensionLoader;
using ExtensionLoader.Config;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class OpenSimMySQLStorage : IExtension<AssetInventoryServer>, IStorageProvider
{
const string EXTENSION_NAME = "OpenSimMySQLStorage"; // Used in metrics reporting
AssetInventoryServer server;
public OpenSimMySQLStorage()
{
}
#region Required Interfaces
public void Start(AssetInventoryServer server)
{
this.server = server;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
try
{
dbConnection.Open();
Logger.Log.Info("Connected to MySQL storage backend: " + dbConnection.ServerVersion);
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL storage backend failed: " + ex.Message);
}
}
}
public void Stop()
{
}
public BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata)
{
metadata = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.ID = assetID;
metadata.Name = reader.GetString(0);
metadata.Description = reader.GetString(1);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
metadata.Temporary = reader.GetBoolean(3);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
return ret;
}
public BackendResponse TryFetchData(UUID assetID, out byte[] assetData)
{
assetData = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT data FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
assetData = (byte[])reader.GetValue(0);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData)
{
metadata = null;
assetData = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary,data FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.ID = assetID;
metadata.Name = reader.GetString(0);
metadata.Description = reader.GetString(1);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
metadata.Temporary = reader.GetBoolean(3);
assetData = (byte[])reader.GetValue(4);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID)
{
assetID = metadata.ID = UUID.Random();
return TryCreateAsset(metadata, assetData);
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData)
{
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
try
{
dbConnection.Open();
MySqlCommand command = new MySqlCommand(
"REPLACE INTO assets (name,description,assetType,local,temporary,data,id) VALUES " +
"(?name,?description,?assetType,?local,?temporary,?data,?id)", dbConnection);
command.Parameters.AddWithValue("?name", metadata.Name);
command.Parameters.AddWithValue("?description", metadata.Description);
command.Parameters.AddWithValue("?assetType", Utils.ContentTypeToSLAssetType(metadata.ContentType));
command.Parameters.AddWithValue("?local", 0);
command.Parameters.AddWithValue("?temporary", metadata.Temporary);
command.Parameters.AddWithValue("?data", assetData);
command.Parameters.AddWithValue("?id", metadata.ID.ToString());
int rowsAffected = command.ExecuteNonQuery();
if (rowsAffected == 1)
{
ret = BackendResponse.Success;
}
else if (rowsAffected == 2)
{
Logger.Log.Info("Replaced asset " + metadata.ID.ToString());
ret = BackendResponse.Success;
}
else
{
Logger.Log.ErrorFormat("MySQL REPLACE query affected {0} rows", rowsAffected);
ret = BackendResponse.Failure;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetCreate(EXTENSION_NAME, ret, metadata.ID, assetData.Length, DateTime.Now);
return ret;
}
public int ForEach(Action<Metadata> action, int start, int count)
{
int rowCount = 0;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
MySqlDataReader reader;
try
{
dbConnection.Open();
MySqlCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary,data,id FROM assets LIMIT {0}, {1}",
start, count);
reader = command.ExecuteReader();
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
return 0;
}
while (reader.Read())
{
Metadata metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.Description = reader.GetString(1);
metadata.ID = UUID.Parse(reader.GetString(5));
metadata.Name = reader.GetString(0);
metadata.SHA1 = OpenMetaverse.Utils.SHA1((byte[])reader.GetValue(4));
metadata.Temporary = reader.GetBoolean(3);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
action(metadata);
++rowCount;
}
reader.Close();
}
return rowCount;
}
#endregion Required Interfaces
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Data;
using MySql.Data.MySqlClient;
using ExtensionLoader;
using ExtensionLoader.Config;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class OpenSimMySQLStorage : IExtension<AssetInventoryServer>, IStorageProvider
{
const string EXTENSION_NAME = "OpenSimMySQLStorage"; // Used in metrics reporting
AssetInventoryServer server;
public OpenSimMySQLStorage()
{
}
#region Required Interfaces
public void Start(AssetInventoryServer server)
{
this.server = server;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
try
{
dbConnection.Open();
Logger.Log.Info("Connected to MySQL storage backend: " + dbConnection.ServerVersion);
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL storage backend failed: " + ex.Message);
}
}
}
public void Stop()
{
}
public BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata)
{
metadata = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.ID = assetID;
metadata.Name = reader.GetString(0);
metadata.Description = reader.GetString(1);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
metadata.Temporary = reader.GetBoolean(3);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
return ret;
}
public BackendResponse TryFetchData(UUID assetID, out byte[] assetData)
{
assetData = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT data FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
assetData = (byte[])reader.GetValue(0);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData)
{
metadata = null;
assetData = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary,data FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.ID = assetID;
metadata.Name = reader.GetString(0);
metadata.Description = reader.GetString(1);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
metadata.Temporary = reader.GetBoolean(3);
assetData = (byte[])reader.GetValue(4);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID)
{
assetID = metadata.ID = UUID.Random();
return TryCreateAsset(metadata, assetData);
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData)
{
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
try
{
dbConnection.Open();
MySqlCommand command = new MySqlCommand(
"REPLACE INTO assets (name,description,assetType,local,temporary,data,id) VALUES " +
"(?name,?description,?assetType,?local,?temporary,?data,?id)", dbConnection);
command.Parameters.AddWithValue("?name", metadata.Name);
command.Parameters.AddWithValue("?description", metadata.Description);
command.Parameters.AddWithValue("?assetType", Utils.ContentTypeToSLAssetType(metadata.ContentType));
command.Parameters.AddWithValue("?local", 0);
command.Parameters.AddWithValue("?temporary", metadata.Temporary);
command.Parameters.AddWithValue("?data", assetData);
command.Parameters.AddWithValue("?id", metadata.ID.ToString());
int rowsAffected = command.ExecuteNonQuery();
if (rowsAffected == 1)
{
ret = BackendResponse.Success;
}
else if (rowsAffected == 2)
{
Logger.Log.Info("Replaced asset " + metadata.ID.ToString());
ret = BackendResponse.Success;
}
else
{
Logger.Log.ErrorFormat("MySQL REPLACE query affected {0} rows", rowsAffected);
ret = BackendResponse.Failure;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetCreate(EXTENSION_NAME, ret, metadata.ID, assetData.Length, DateTime.Now);
return ret;
}
public int ForEach(Action<Metadata> action, int start, int count)
{
int rowCount = 0;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
MySqlDataReader reader;
try
{
dbConnection.Open();
MySqlCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary,data,id FROM assets LIMIT {0}, {1}",
start, count);
reader = command.ExecuteReader();
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
return 0;
}
while (reader.Read())
{
Metadata metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.Description = reader.GetString(1);
metadata.ID = UUID.Parse(reader.GetString(5));
metadata.Name = reader.GetString(0);
metadata.SHA1 = OpenMetaverse.Utils.SHA1((byte[])reader.GetValue(4));
metadata.Temporary = reader.GetBoolean(3);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
action(metadata);
++rowCount;
}
reader.Close();
}
return rowCount;
}
#endregion Required Interfaces
}
}

478
OpenSim/Grid/AssetInventoryServer/Extensions/ReferenceFrontend.cs
View File

@ -1,239 +1,239 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Xml;
using ExtensionLoader;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using HttpServer;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class ReferenceFrontend : IExtension<AssetInventoryServer>
{
AssetInventoryServer server;
public ReferenceFrontend()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
// Asset metadata request
server.HttpServer.AddHandler("get", null, @"^/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/metadata",
MetadataRequestHandler);
// Asset data request
server.HttpServer.AddHandler("get", null, @"^/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/data",
DataRequestHandler);
// Asset creation
server.HttpServer.AddHandler("post", null, "^/createasset", CreateRequestHandler);
}
public void Stop()
{
}
bool MetadataRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up into an AssetID and a method
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && UUID.TryParse(rawUrl[1], out assetID))
{
UUID authToken = Utils.GetAuthToken(request);
if (server.AuthorizationProvider.IsMetadataAuthorized(authToken, assetID))
{
Metadata metadata;
BackendResponse storageResponse = server.StorageProvider.TryFetchMetadata(assetID, out metadata);
if (storageResponse == BackendResponse.Success)
{
// If the asset data location wasn't specified in the metadata, specify it
// manually here by pointing back to this asset server
if (!metadata.Methods.ContainsKey("data"))
{
metadata.Methods["data"] = new Uri(String.Format("{0}://{1}/{2}/data",
request.Uri.Scheme, request.Uri.Authority, assetID));
}
byte[] serializedData = metadata.SerializeToBytes();
response.Status = HttpStatusCode.OK;
response.ContentType = "application/json";
response.ContentLength = serializedData.Length;
response.Body.Write(serializedData, 0, serializedData.Length);
}
else if (storageResponse == BackendResponse.NotFound)
{
Logger.Log.Warn("Could not find metadata for asset " + assetID.ToString());
response.Status = HttpStatusCode.NotFound;
}
else
{
response.Status = HttpStatusCode.InternalServerError;
}
}
else
{
response.Status = HttpStatusCode.Forbidden;
}
return true;
}
response.Status = HttpStatusCode.NotFound;
return true;
}
bool DataRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up into an AssetID and a method
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && UUID.TryParse(rawUrl[1], out assetID))
{
UUID authToken = Utils.GetAuthToken(request);
if (server.AuthorizationProvider.IsDataAuthorized(authToken, assetID))
{
byte[] assetData;
BackendResponse storageResponse = server.StorageProvider.TryFetchData(assetID, out assetData);
if (storageResponse == BackendResponse.Success)
{
response.Status = HttpStatusCode.OK;
response.Status = HttpStatusCode.OK;
response.ContentType = "application/octet-stream";
response.AddHeader("Content-Disposition", "attachment; filename=" + assetID.ToString());
response.ContentLength = assetData.Length;
response.Body.Write(assetData, 0, assetData.Length);
}
else if (storageResponse == BackendResponse.NotFound)
{
response.Status = HttpStatusCode.NotFound;
}
else
{
response.Status = HttpStatusCode.InternalServerError;
}
}
else
{
response.Status = HttpStatusCode.Forbidden;
}
return true;
}
response.Status = HttpStatusCode.BadRequest;
return true;
}
bool CreateRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID authToken = Utils.GetAuthToken(request);
if (server.AuthorizationProvider.IsCreateAuthorized(authToken))
{
try
{
OSD osdata = OSDParser.DeserializeJson(request.Body);
if (osdata.Type == OSDType.Map)
{
OSDMap map = (OSDMap)osdata;
Metadata metadata = new Metadata();
metadata.Deserialize(map);
byte[] assetData = map["data"].AsBinary();
if (assetData != null && assetData.Length > 0)
{
BackendResponse storageResponse;
if (metadata.ID != UUID.Zero)
storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData);
else
storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData, out metadata.ID);
if (storageResponse == BackendResponse.Success)
{
response.Status = HttpStatusCode.Created;
OSDMap responseMap = new OSDMap(1);
responseMap["id"] = OSD.FromUUID(metadata.ID);
LitJson.JsonData jsonData = OSDParser.SerializeJson(responseMap);
byte[] responseData = System.Text.Encoding.UTF8.GetBytes(jsonData.ToJson());
response.Body.Write(responseData, 0, responseData.Length);
response.Body.Flush();
}
else if (storageResponse == BackendResponse.NotFound)
{
response.Status = HttpStatusCode.NotFound;
}
else
{
response.Status = HttpStatusCode.InternalServerError;
}
}
else
{
response.Status = HttpStatusCode.BadRequest;
}
}
else
{
response.Status = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
response.Status = HttpStatusCode.InternalServerError;
response.Reason = ex.Message;
}
}
else
{
response.Status = HttpStatusCode.Forbidden;
}
return true;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Xml;
using ExtensionLoader;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using HttpServer;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class ReferenceFrontend : IExtension<AssetInventoryServer>
{
AssetInventoryServer server;
public ReferenceFrontend()
{
}
public void Start(AssetInventoryServer server)
{
this.server = server;
// Asset metadata request
server.HttpServer.AddHandler("get", null, @"^/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/metadata",
MetadataRequestHandler);
// Asset data request
server.HttpServer.AddHandler("get", null, @"^/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/data",
DataRequestHandler);
// Asset creation
server.HttpServer.AddHandler("post", null, "^/createasset", CreateRequestHandler);
}
public void Stop()
{
}
bool MetadataRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up into an AssetID and a method
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && UUID.TryParse(rawUrl[1], out assetID))
{
UUID authToken = Utils.GetAuthToken(request);
if (server.AuthorizationProvider.IsMetadataAuthorized(authToken, assetID))
{
Metadata metadata;
BackendResponse storageResponse = server.StorageProvider.TryFetchMetadata(assetID, out metadata);
if (storageResponse == BackendResponse.Success)
{
// If the asset data location wasn't specified in the metadata, specify it
// manually here by pointing back to this asset server
if (!metadata.Methods.ContainsKey("data"))
{
metadata.Methods["data"] = new Uri(String.Format("{0}://{1}/{2}/data",
request.Uri.Scheme, request.Uri.Authority, assetID));
}
byte[] serializedData = metadata.SerializeToBytes();
response.Status = HttpStatusCode.OK;
response.ContentType = "application/json";
response.ContentLength = serializedData.Length;
response.Body.Write(serializedData, 0, serializedData.Length);
}
else if (storageResponse == BackendResponse.NotFound)
{
Logger.Log.Warn("Could not find metadata for asset " + assetID.ToString());
response.Status = HttpStatusCode.NotFound;
}
else
{
response.Status = HttpStatusCode.InternalServerError;
}
}
else
{
response.Status = HttpStatusCode.Forbidden;
}
return true;
}
response.Status = HttpStatusCode.NotFound;
return true;
}
bool DataRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up into an AssetID and a method
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && UUID.TryParse(rawUrl[1], out assetID))
{
UUID authToken = Utils.GetAuthToken(request);
if (server.AuthorizationProvider.IsDataAuthorized(authToken, assetID))
{
byte[] assetData;
BackendResponse storageResponse = server.StorageProvider.TryFetchData(assetID, out assetData);
if (storageResponse == BackendResponse.Success)
{
response.Status = HttpStatusCode.OK;
response.Status = HttpStatusCode.OK;
response.ContentType = "application/octet-stream";
response.AddHeader("Content-Disposition", "attachment; filename=" + assetID.ToString());
response.ContentLength = assetData.Length;
response.Body.Write(assetData, 0, assetData.Length);
}
else if (storageResponse == BackendResponse.NotFound)
{
response.Status = HttpStatusCode.NotFound;
}
else
{
response.Status = HttpStatusCode.InternalServerError;
}
}
else
{
response.Status = HttpStatusCode.Forbidden;
}
return true;
}
response.Status = HttpStatusCode.BadRequest;
return true;
}
bool CreateRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID authToken = Utils.GetAuthToken(request);
if (server.AuthorizationProvider.IsCreateAuthorized(authToken))
{
try
{
OSD osdata = OSDParser.DeserializeJson(request.Body);
if (osdata.Type == OSDType.Map)
{
OSDMap map = (OSDMap)osdata;
Metadata metadata = new Metadata();
metadata.Deserialize(map);
byte[] assetData = map["data"].AsBinary();
if (assetData != null && assetData.Length > 0)
{
BackendResponse storageResponse;
if (metadata.ID != UUID.Zero)
storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData);
else
storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData, out metadata.ID);
if (storageResponse == BackendResponse.Success)
{
response.Status = HttpStatusCode.Created;
OSDMap responseMap = new OSDMap(1);
responseMap["id"] = OSD.FromUUID(metadata.ID);
LitJson.JsonData jsonData = OSDParser.SerializeJson(responseMap);
byte[] responseData = System.Text.Encoding.UTF8.GetBytes(jsonData.ToJson());
response.Body.Write(responseData, 0, responseData.Length);
response.Body.Flush();
}
else if (storageResponse == BackendResponse.NotFound)
{
response.Status = HttpStatusCode.NotFound;
}
else
{
response.Status = HttpStatusCode.InternalServerError;
}
}
else
{
response.Status = HttpStatusCode.BadRequest;
}
}
else
{
response.Status = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
response.Status = HttpStatusCode.InternalServerError;
response.Reason = ex.Message;
}
}
else
{
response.Status = HttpStatusCode.Forbidden;
}
return true;
}
}
}

1204
OpenSim/Grid/AssetInventoryServer/Extensions/SimpleInventory.cs
View File

File diff suppressed because it is too large Load Diff

520
OpenSim/Grid/AssetInventoryServer/Extensions/SimpleStorage.cs
View File

@ -1,260 +1,260 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using ExtensionLoader;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class SimpleStorage : IExtension<AssetInventoryServer>, IStorageProvider
{
const string EXTENSION_NAME = ""; // Used in metrics reporting
const string DEFAULT_DATA_DIR = "SimpleAssets";
const string TEMP_DATA_DIR = "SimpleAssetsTemp";
AssetInventoryServer server;
Dictionary<UUID, Metadata> metadataStorage;
Dictionary<UUID, string> filenames;
public SimpleStorage()
{
}
#region Required Interfaces
public void Start(AssetInventoryServer server)
{
this.server = server;
metadataStorage = new Dictionary<UUID, Metadata>();
filenames = new Dictionary<UUID, string>();
LoadFiles(DEFAULT_DATA_DIR, false);
LoadFiles(TEMP_DATA_DIR, true);
Logger.Log.InfoFormat("Initialized the store index with metadata for {0} assets",
metadataStorage.Count);
}
public void Stop()
{
WipeTemporary();
}
public BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata)
{
metadata = null;
BackendResponse ret;
if (metadataStorage.TryGetValue(assetID, out metadata))
ret = BackendResponse.Success;
else
ret = BackendResponse.NotFound;
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
return ret;
}
public BackendResponse TryFetchData(UUID assetID, out byte[] assetData)
{
assetData = null;
string filename;
BackendResponse ret;
if (filenames.TryGetValue(assetID, out filename))
{
try
{
assetData = File.ReadAllBytes(filename);
ret = BackendResponse.Success;
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Failed reading data for asset {0} from {1}: {2}", assetID, filename, ex.Message);
ret = BackendResponse.Failure;
}
}
else
{
ret = BackendResponse.NotFound;
}
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData)
{
metadata = null;
assetData = null;
string filename;
BackendResponse ret;
if (metadataStorage.TryGetValue(assetID, out metadata) &&
filenames.TryGetValue(assetID, out filename))
{
try
{
assetData = File.ReadAllBytes(filename);
ret = BackendResponse.Success;
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Failed reading data for asset {0} from {1}: {2}", assetID, filename, ex.Message);
ret = BackendResponse.Failure;
}
}
else
{
ret = BackendResponse.NotFound;
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID)
{
assetID = metadata.ID = UUID.Random();
return TryCreateAsset(metadata, assetData);
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData)
{
BackendResponse ret;
string path;
string filename = String.Format("{0}.{1}", metadata.ID, Utils.ContentTypeToExtension(metadata.ContentType));
if (metadata.Temporary)
path = Path.Combine(TEMP_DATA_DIR, filename);
else
path = Path.Combine(DEFAULT_DATA_DIR, filename);
try
{
File.WriteAllBytes(path, assetData);
lock (filenames) filenames[metadata.ID] = path;
// Set the creation date to right now
metadata.CreationDate = DateTime.Now;
lock (metadataStorage)
metadataStorage[metadata.ID] = metadata;
ret = BackendResponse.Success;
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Failed writing data for asset {0} to {1}: {2}", metadata.ID, filename, ex.Message);
ret = BackendResponse.Failure;
}
server.MetricsProvider.LogAssetCreate(EXTENSION_NAME, ret, metadata.ID, assetData.Length, DateTime.Now);
return ret;
}
public int ForEach(Action<Metadata> action, int start, int count)
{
int rowCount = 0;
lock (metadataStorage)
{
foreach (Metadata metadata in metadataStorage.Values)
{
action(metadata);
++rowCount;
}
}
return rowCount;
}
#endregion Required Interfaces
public void WipeTemporary()
{
if (Directory.Exists(TEMP_DATA_DIR))
{
try { Directory.Delete(TEMP_DATA_DIR); }
catch (Exception ex) { Logger.Log.Error(ex.Message); }
}
}
void LoadFiles(string folder, bool temporary)
{
// Try to create the directory if it doesn't already exist
if (!Directory.Exists(folder))
{
try { Directory.CreateDirectory(folder); }
catch (Exception ex)
{
Logger.Log.Warn(ex.Message);
return;
}
}
lock (metadataStorage)
{
try
{
string[] assets = Directory.GetFiles(folder);
for (int i = 0; i < assets.Length; i++)
{
string filename = assets[i];
byte[] data = File.ReadAllBytes(filename);
Metadata metadata = new Metadata();
metadata.CreationDate = File.GetCreationTime(filename);
metadata.Description = String.Empty;
metadata.ID = SimpleUtils.ParseUUIDFromFilename(filename);
metadata.Name = SimpleUtils.ParseNameFromFilename(filename);
metadata.SHA1 = OpenMetaverse.Utils.SHA1(data);
metadata.Temporary = false;
metadata.ContentType = Utils.ExtensionToContentType(Path.GetExtension(filename).TrimStart('.'));
// Store the loaded data
metadataStorage[metadata.ID] = metadata;
filenames[metadata.ID] = filename;
}
}
catch (Exception ex)
{
Logger.Log.Warn(ex.Message);
}
}
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using ExtensionLoader;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public class SimpleStorage : IExtension<AssetInventoryServer>, IStorageProvider
{
const string EXTENSION_NAME = ""; // Used in metrics reporting
const string DEFAULT_DATA_DIR = "SimpleAssets";
const string TEMP_DATA_DIR = "SimpleAssetsTemp";
AssetInventoryServer server;
Dictionary<UUID, Metadata> metadataStorage;
Dictionary<UUID, string> filenames;
public SimpleStorage()
{
}
#region Required Interfaces
public void Start(AssetInventoryServer server)
{
this.server = server;
metadataStorage = new Dictionary<UUID, Metadata>();
filenames = new Dictionary<UUID, string>();
LoadFiles(DEFAULT_DATA_DIR, false);
LoadFiles(TEMP_DATA_DIR, true);
Logger.Log.InfoFormat("Initialized the store index with metadata for {0} assets",
metadataStorage.Count);
}
public void Stop()
{
WipeTemporary();
}
public BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata)
{
metadata = null;
BackendResponse ret;
if (metadataStorage.TryGetValue(assetID, out metadata))
ret = BackendResponse.Success;
else
ret = BackendResponse.NotFound;
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
return ret;
}
public BackendResponse TryFetchData(UUID assetID, out byte[] assetData)
{
assetData = null;
string filename;
BackendResponse ret;
if (filenames.TryGetValue(assetID, out filename))
{
try
{
assetData = File.ReadAllBytes(filename);
ret = BackendResponse.Success;
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Failed reading data for asset {0} from {1}: {2}", assetID, filename, ex.Message);
ret = BackendResponse.Failure;
}
}
else
{
ret = BackendResponse.NotFound;
}
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData)
{
metadata = null;
assetData = null;
string filename;
BackendResponse ret;
if (metadataStorage.TryGetValue(assetID, out metadata) &&
filenames.TryGetValue(assetID, out filename))
{
try
{
assetData = File.ReadAllBytes(filename);
ret = BackendResponse.Success;
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Failed reading data for asset {0} from {1}: {2}", assetID, filename, ex.Message);
ret = BackendResponse.Failure;
}
}
else
{
ret = BackendResponse.NotFound;
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID)
{
assetID = metadata.ID = UUID.Random();
return TryCreateAsset(metadata, assetData);
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData)
{
BackendResponse ret;
string path;
string filename = String.Format("{0}.{1}", metadata.ID, Utils.ContentTypeToExtension(metadata.ContentType));
if (metadata.Temporary)
path = Path.Combine(TEMP_DATA_DIR, filename);
else
path = Path.Combine(DEFAULT_DATA_DIR, filename);
try
{
File.WriteAllBytes(path, assetData);
lock (filenames) filenames[metadata.ID] = path;
// Set the creation date to right now
metadata.CreationDate = DateTime.Now;
lock (metadataStorage)
metadataStorage[metadata.ID] = metadata;
ret = BackendResponse.Success;
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Failed writing data for asset {0} to {1}: {2}", metadata.ID, filename, ex.Message);
ret = BackendResponse.Failure;
}
server.MetricsProvider.LogAssetCreate(EXTENSION_NAME, ret, metadata.ID, assetData.Length, DateTime.Now);
return ret;
}
public int ForEach(Action<Metadata> action, int start, int count)
{
int rowCount = 0;
lock (metadataStorage)
{
foreach (Metadata metadata in metadataStorage.Values)
{
action(metadata);
++rowCount;
}
}
return rowCount;
}
#endregion Required Interfaces
public void WipeTemporary()
{
if (Directory.Exists(TEMP_DATA_DIR))
{
try { Directory.Delete(TEMP_DATA_DIR); }
catch (Exception ex) { Logger.Log.Error(ex.Message); }
}
}
void LoadFiles(string folder, bool temporary)
{
// Try to create the directory if it doesn't already exist
if (!Directory.Exists(folder))
{
try { Directory.CreateDirectory(folder); }
catch (Exception ex)
{
Logger.Log.Warn(ex.Message);
return;
}
}
lock (metadataStorage)
{
try
{
string[] assets = Directory.GetFiles(folder);
for (int i = 0; i < assets.Length; i++)
{
string filename = assets[i];
byte[] data = File.ReadAllBytes(filename);
Metadata metadata = new Metadata();
metadata.CreationDate = File.GetCreationTime(filename);
metadata.Description = String.Empty;
metadata.ID = SimpleUtils.ParseUUIDFromFilename(filename);
metadata.Name = SimpleUtils.ParseNameFromFilename(filename);
metadata.SHA1 = OpenMetaverse.Utils.SHA1(data);
metadata.Temporary = false;
metadata.ContentType = Utils.ExtensionToContentType(Path.GetExtension(filename).TrimStart('.'));
// Store the loaded data
metadataStorage[metadata.ID] = metadata;
filenames[metadata.ID] = filename;
}
}
catch (Exception ex)
{
Logger.Log.Warn(ex.Message);
}
}
}
}
}

88
OpenSim/Grid/AssetInventoryServer/Extensions/SimpleUtils.cs
View File

@ -1,44 +1,44 @@
using System;
using System.IO;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public static class SimpleUtils
{
public static string ParseNameFromFilename(string filename)
{
filename = Path.GetFileName(filename);
int dot = filename.LastIndexOf('.');
int firstDash = filename.IndexOf('-');
if (dot - 37 > 0 && firstDash > 0)
return filename.Substring(0, firstDash);
else
return String.Empty;
}
public static UUID ParseUUIDFromFilename(string filename)
{
int dot = filename.LastIndexOf('.');
if (dot > 35)
{
// Grab the last 36 characters of the filename
string uuidString = filename.Substring(dot - 36, 36);
UUID uuid;
UUID.TryParse(uuidString, out uuid);
return uuid;
}
else
{
UUID uuid;
if (UUID.TryParse(Path.GetFileName(filename), out uuid))
return uuid;
else
return UUID.Zero;
}
}
}
}
using System;
using System.IO;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer.Extensions
{
public static class SimpleUtils
{
public static string ParseNameFromFilename(string filename)
{
filename = Path.GetFileName(filename);
int dot = filename.LastIndexOf('.');
int firstDash = filename.IndexOf('-');
if (dot - 37 > 0 && firstDash > 0)
return filename.Substring(0, firstDash);
else
return String.Empty;
}
public static UUID ParseUUIDFromFilename(string filename)
{
int dot = filename.LastIndexOf('.');
if (dot > 35)
{
// Grab the last 36 characters of the filename
string uuidString = filename.Substring(dot - 36, 36);
UUID uuid;
UUID.TryParse(uuidString, out uuid);
return uuid;
}
else
{
UUID uuid;
if (UUID.TryParse(Path.GetFileName(filename), out uuid))
return uuid;
else
return UUID.Zero;
}
}
}
}

314
OpenSim/Grid/AssetInventoryServer/Interfaces.cs
View File

@ -1,157 +1,157 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using OpenSim.Framework;
namespace OpenSim.Grid.AssetInventoryServer
{
/// <summary>
/// Response from a call to a backend provider
/// </summary>
public enum BackendResponse
{
/// <summary>The call succeeded</summary>
Success,
/// <summary>The resource requested was not found</summary>
NotFound,
/// <summary>A server failure prevented the call from
/// completing</summary>
Failure
}
public class AssetInventoryServerPluginInitialiser : PluginInitialiserBase
{
private AssetInventoryServer server;
public AssetInventoryServerPluginInitialiser (AssetInventoryServer server)
{
this.server = server;
}
public override void Initialise (IPlugin plugin)
{
IAssetInventoryServerPlugin p = plugin as IAssetInventoryServerPlugin;
p.Initialise (server);
}
}
#region Interfaces
public interface IAssetInventoryServerPlugin : IPlugin
{
void Initialise(AssetInventoryServer server);
}
public interface IStorageProvider
{
BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata);
BackendResponse TryFetchData(UUID assetID, out byte[] assetData);
BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID);
int ForEach(Action<Metadata> action, int start, int count);
}
public interface IAssetStorageProvider : IAssetInventoryServerPlugin
{
BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata);
BackendResponse TryFetchData(UUID assetID, out byte[] assetData);
BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID);
int ForEach(Action<Metadata> action, int start, int count);
}
public interface IInventoryProvider
{
BackendResponse TryFetchItem(Uri owner, UUID itemID, out InventoryItem item);
BackendResponse TryFetchFolder(Uri owner, UUID folderID, out InventoryFolder folder);
BackendResponse TryFetchFolderContents(Uri owner, UUID folderID, out InventoryCollection contents);
BackendResponse TryFetchFolderList(Uri owner, out List<InventoryFolder> folders);
BackendResponse TryFetchInventory(Uri owner, out InventoryCollection inventory);
BackendResponse TryFetchActiveGestures(Uri owner, out List<InventoryItem> gestures);
BackendResponse TryCreateItem(Uri owner, InventoryItem item);
BackendResponse TryCreateFolder(Uri owner, InventoryFolder folder);
BackendResponse TryCreateInventory(Uri owner, InventoryFolder rootFolder);
BackendResponse TryDeleteItem(Uri owner, UUID itemID);
BackendResponse TryDeleteFolder(Uri owner, UUID folderID);
BackendResponse TryPurgeFolder(Uri owner, UUID folderID);
}
public interface IAuthenticationProvider
{
void AddIdentifier(UUID authToken, Uri identifier);
bool RemoveIdentifier(UUID authToken);
bool TryGetIdentifier(UUID authToken, out Uri identifier);
}
public interface IAuthorizationProvider
{
bool IsMetadataAuthorized(UUID authToken, UUID assetID);
/// <summary>
/// Authorizes access to the data for an asset. Access to asset data
/// also implies access to the metadata for that asset
/// </summary>
/// <param name="authToken">Authentication token to check for access</param>
/// <param name="assetID">ID of the requested asset</param>
/// <returns>True if access is granted, otherwise false</returns>
bool IsDataAuthorized(UUID authToken, UUID assetID);
bool IsCreateAuthorized(UUID authToken);
bool IsInventoryReadAuthorized(UUID authToken, Uri owner);
bool IsInventoryWriteAuthorized(UUID authToken, Uri owner);
}
public interface IMetricsProvider
{
void LogAssetMetadataFetch(string extension, BackendResponse response, UUID assetID, DateTime time);
void LogAssetDataFetch(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time);
void LogAssetCreate(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time);
void LogInventoryFetch(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time);
void LogInventoryFetchFolderContents(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time);
void LogInventoryFetchFolderList(string extension, BackendResponse response, Uri owner, DateTime time);
void LogInventoryFetchInventory(string extension, BackendResponse response, Uri owner, DateTime time);
void LogInventoryFetchActiveGestures(string extension, BackendResponse response, Uri owner, DateTime time);
void LogInventoryCreate(string extension, BackendResponse response, Uri owner, bool folder, DateTime time);
void LogInventoryCreateInventory(string extension, BackendResponse response, DateTime time);
void LogInventoryDelete(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time);
void LogInventoryPurgeFolder(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time);
}
#endregion Interfaces
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using OpenSim.Framework;
namespace OpenSim.Grid.AssetInventoryServer
{
/// <summary>
/// Response from a call to a backend provider
/// </summary>
public enum BackendResponse
{
/// <summary>The call succeeded</summary>
Success,
/// <summary>The resource requested was not found</summary>
NotFound,
/// <summary>A server failure prevented the call from
/// completing</summary>
Failure
}
public class AssetInventoryServerPluginInitialiser : PluginInitialiserBase
{
private AssetInventoryServer server;
public AssetInventoryServerPluginInitialiser (AssetInventoryServer server)
{
this.server = server;
}
public override void Initialise (IPlugin plugin)
{
IAssetInventoryServerPlugin p = plugin as IAssetInventoryServerPlugin;
p.Initialise (server);
}
}
#region Interfaces
public interface IAssetInventoryServerPlugin : IPlugin
{
void Initialise(AssetInventoryServer server);
}
public interface IStorageProvider
{
BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata);
BackendResponse TryFetchData(UUID assetID, out byte[] assetData);
BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID);
int ForEach(Action<Metadata> action, int start, int count);
}
public interface IAssetStorageProvider : IAssetInventoryServerPlugin
{
BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata);
BackendResponse TryFetchData(UUID assetID, out byte[] assetData);
BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData);
BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID);
int ForEach(Action<Metadata> action, int start, int count);
}
public interface IInventoryProvider
{
BackendResponse TryFetchItem(Uri owner, UUID itemID, out InventoryItem item);
BackendResponse TryFetchFolder(Uri owner, UUID folderID, out InventoryFolder folder);
BackendResponse TryFetchFolderContents(Uri owner, UUID folderID, out InventoryCollection contents);
BackendResponse TryFetchFolderList(Uri owner, out List<InventoryFolder> folders);
BackendResponse TryFetchInventory(Uri owner, out InventoryCollection inventory);
BackendResponse TryFetchActiveGestures(Uri owner, out List<InventoryItem> gestures);
BackendResponse TryCreateItem(Uri owner, InventoryItem item);
BackendResponse TryCreateFolder(Uri owner, InventoryFolder folder);
BackendResponse TryCreateInventory(Uri owner, InventoryFolder rootFolder);
BackendResponse TryDeleteItem(Uri owner, UUID itemID);
BackendResponse TryDeleteFolder(Uri owner, UUID folderID);
BackendResponse TryPurgeFolder(Uri owner, UUID folderID);
}
public interface IAuthenticationProvider
{
void AddIdentifier(UUID authToken, Uri identifier);
bool RemoveIdentifier(UUID authToken);
bool TryGetIdentifier(UUID authToken, out Uri identifier);
}
public interface IAuthorizationProvider
{
bool IsMetadataAuthorized(UUID authToken, UUID assetID);
/// <summary>
/// Authorizes access to the data for an asset. Access to asset data
/// also implies access to the metadata for that asset
/// </summary>
/// <param name="authToken">Authentication token to check for access</param>
/// <param name="assetID">ID of the requested asset</param>
/// <returns>True if access is granted, otherwise false</returns>
bool IsDataAuthorized(UUID authToken, UUID assetID);
bool IsCreateAuthorized(UUID authToken);
bool IsInventoryReadAuthorized(UUID authToken, Uri owner);
bool IsInventoryWriteAuthorized(UUID authToken, Uri owner);
}
public interface IMetricsProvider
{
void LogAssetMetadataFetch(string extension, BackendResponse response, UUID assetID, DateTime time);
void LogAssetDataFetch(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time);
void LogAssetCreate(string extension, BackendResponse response, UUID assetID, int dataSize, DateTime time);
void LogInventoryFetch(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time);
void LogInventoryFetchFolderContents(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time);
void LogInventoryFetchFolderList(string extension, BackendResponse response, Uri owner, DateTime time);
void LogInventoryFetchInventory(string extension, BackendResponse response, Uri owner, DateTime time);
void LogInventoryFetchActiveGestures(string extension, BackendResponse response, Uri owner, DateTime time);
void LogInventoryCreate(string extension, BackendResponse response, Uri owner, bool folder, DateTime time);
void LogInventoryCreateInventory(string extension, BackendResponse response, DateTime time);
void LogInventoryDelete(string extension, BackendResponse response, Uri owner, UUID objID, bool folder, DateTime time);
void LogInventoryPurgeFolder(string extension, BackendResponse response, Uri owner, UUID folderID, DateTime time);
}
#endregion Interfaces
}

214
OpenSim/Grid/AssetInventoryServer/InventoryObjects.cs
View File

@ -1,107 +1,107 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer
{
public class InventoryBase
{
}
public class InventoryFolder : InventoryBase
{
public string Name;
public UUID Owner;
public UUID ParentID;
public UUID ID;
public short Type;
public ushort Version;
[NonSerialized]
public Dictionary<UUID, InventoryBase> Children = new Dictionary<UUID, InventoryBase>();
public InventoryFolder()
{
}
public InventoryFolder(string name, UUID ownerID, UUID parentID, short assetType)
{
ID = UUID.Random();
Name = name;
Owner = ownerID;
ParentID = parentID;
Type = assetType;
Version = 1;
}
public override string ToString()
{
return String.Format("{0} ({1})", Name, ID);
}
}
public class InventoryItem : InventoryBase
{
public UUID ID;
public int InvType;
public UUID Folder;
public UUID Owner;
public UUID Creator;
public string Name;
public string Description;
public uint NextPermissions;
public uint CurrentPermissions;
public uint BasePermissions;
public uint EveryOnePermissions;
public uint GroupPermissions;
public int AssetType;
public UUID AssetID;
public UUID GroupID;
public bool GroupOwned;
public int SalePrice;
public byte SaleType;
public uint Flags;
public int CreationDate;
public override string ToString()
{
return String.Format("{0} ({1})", Name, ID);
}
}
public class InventoryCollection
{
public Dictionary<UUID, InventoryFolder> Folders;
public Dictionary<UUID, InventoryItem> Items;
public UUID UserID;
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using OpenMetaverse;
namespace OpenSim.Grid.AssetInventoryServer
{
public class InventoryBase
{
}
public class InventoryFolder : InventoryBase
{
public string Name;
public UUID Owner;
public UUID ParentID;
public UUID ID;
public short Type;
public ushort Version;
[NonSerialized]
public Dictionary<UUID, InventoryBase> Children = new Dictionary<UUID, InventoryBase>();
public InventoryFolder()
{
}
public InventoryFolder(string name, UUID ownerID, UUID parentID, short assetType)
{
ID = UUID.Random();
Name = name;
Owner = ownerID;
ParentID = parentID;
Type = assetType;
Version = 1;
}
public override string ToString()
{
return String.Format("{0} ({1})", Name, ID);
}
}
public class InventoryItem : InventoryBase
{
public UUID ID;
public int InvType;
public UUID Folder;
public UUID Owner;
public UUID Creator;
public string Name;
public string Description;
public uint NextPermissions;
public uint CurrentPermissions;
public uint BasePermissions;
public uint EveryOnePermissions;
public uint GroupPermissions;
public int AssetType;
public UUID AssetID;
public UUID GroupID;
public bool GroupOwned;
public int SalePrice;
public byte SaleType;
public uint Flags;
public int CreationDate;
public override string ToString()
{
return String.Format("{0} ({1})", Name, ID);
}
}
public class InventoryCollection
{
public Dictionary<UUID, InventoryFolder> Folders;
public Dictionary<UUID, InventoryItem> Items;
public UUID UserID;
}
}

124
OpenSim/Grid/AssetInventoryServer/Logger.cs
View File

@ -1,62 +1,62 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using log4net;
using log4net.Config;
[assembly: log4net.Config.XmlConfigurator(ConfigFileExtension = "log4net")]
namespace OpenSim.Grid.AssetInventoryServer
{
/// <summary>
/// Singleton logging class for the entire library
/// </summary>
public static class Logger
{
/// <summary>log4net logging engine</summary>
public static ILog Log;
static Logger()
{
Log = LogManager.GetLogger(System.Reflection.Assembly.GetExecutingAssembly().FullName);
// If error level reporting isn't enabled we assume no logger is configured and initialize a default
// ConsoleAppender
if (!Log.Logger.IsEnabledFor(log4net.Core.Level.Error))
{
log4net.Appender.ConsoleAppender appender = new log4net.Appender.ConsoleAppender();
appender.Layout = new log4net.Layout.PatternLayout("%timestamp [%thread] %-5level - %message%newline");
BasicConfigurator.Configure(appender);
Log.Info("No log configuration found, defaulting to console logging");
}
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using log4net;
using log4net.Config;
[assembly: log4net.Config.XmlConfigurator(ConfigFileExtension = "log4net")]
namespace OpenSim.Grid.AssetInventoryServer
{
/// <summary>
/// Singleton logging class for the entire library
/// </summary>
public static class Logger
{
/// <summary>log4net logging engine</summary>
public static ILog Log;
static Logger()
{
Log = LogManager.GetLogger(System.Reflection.Assembly.GetExecutingAssembly().FullName);
// If error level reporting isn't enabled we assume no logger is configured and initialize a default
// ConsoleAppender
if (!Log.Logger.IsEnabledFor(log4net.Core.Level.Error))
{
log4net.Appender.ConsoleAppender appender = new log4net.Appender.ConsoleAppender();
appender.Layout = new log4net.Layout.PatternLayout("%timestamp [%thread] %-5level - %message%newline");
BasicConfigurator.Configure(appender);
Log.Info("No log configuration found, defaulting to console logging");
}
}
}
}

124
OpenSim/Grid/AssetInventoryServer/Main.cs
View File

@ -1,62 +1,62 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.ServiceProcess;
namespace OpenSim.Grid.AssetInventoryServer
{
class MainEntry
{
static void Main(string[] args)
{
#if DEBUG
AssetInventoryServer server = new AssetInventoryServer();
if (server.Start())
{
Console.WriteLine("Asset server is running. Press CTRL+C to quit");
Console.CancelKeyPress +=
delegate(object sender, ConsoleCancelEventArgs e)
{
Console.WriteLine("Asset server is shutting down...");
server.Shutdown();
Environment.Exit(0);
};
while (true)
Console.ReadLine();
}
#else
ServiceBase[] servicesToRun = new ServiceBase[] { new AssetInventoryServer() };
ServiceBase.Run(servicesToRun);
#endif
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.ServiceProcess;
namespace OpenSim.Grid.AssetInventoryServer
{
class MainEntry
{
static void Main(string[] args)
{
#if DEBUG
AssetInventoryServer server = new AssetInventoryServer();
if (server.Start())
{
Console.WriteLine("Asset server is running. Press CTRL+C to quit");
Console.CancelKeyPress +=
delegate(object sender, ConsoleCancelEventArgs e)
{
Console.WriteLine("Asset server is shutting down...");
server.Shutdown();
Environment.Exit(0);
};
while (true)
Console.ReadLine();
}
#else
ServiceBase[] servicesToRun = new ServiceBase[] { new AssetInventoryServer() };
ServiceBase.Run(servicesToRun);
#endif
}
}
}

170
OpenSim/Grid/AssetInventoryServer/Metadata.cs
View File

@ -1,85 +1,85 @@
using System;
using System.Collections.Generic;
using System.Xml;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
namespace OpenSim.Grid.AssetInventoryServer
{
public class Metadata
{
public UUID ID;
public string Name;
public string Description;
public DateTime CreationDate;
public string ContentType;
public byte[] SHA1;
public bool Temporary;
public Dictionary<string, Uri> Methods = new Dictionary<string, Uri>();
public OSDMap ExtraData;
public OSDMap SerializeToOSD()
{
OSDMap osdata = new OSDMap();
if (ID != UUID.Zero) osdata["id"] = OSD.FromUUID(ID);
osdata["name"] = OSD.FromString(Name);
osdata["description"] = OSD.FromString(Description);
osdata["creation_date"] = OSD.FromDate(CreationDate);
osdata["type"] = OSD.FromString(ContentType);
osdata["sha1"] = OSD.FromBinary(SHA1);
osdata["temporary"] = OSD.FromBoolean(Temporary);
OSDMap methods = new OSDMap(Methods.Count);
foreach (KeyValuePair<string, Uri> kvp in Methods)
methods.Add(kvp.Key, OSD.FromUri(kvp.Value));
osdata["methods"] = methods;
if (ExtraData != null) osdata["extra_data"] = ExtraData;
return osdata;
}
public byte[] SerializeToBytes()
{
LitJson.JsonData jsonData = OSDParser.SerializeJson(SerializeToOSD());
return System.Text.Encoding.UTF8.GetBytes(jsonData.ToJson());
}
public void Deserialize(byte[] data)
{
OSD osdata = OSDParser.DeserializeJson(System.Text.Encoding.UTF8.GetString(data));
Deserialize(osdata);
}
public void Deserialize(string data)
{
OSD osdata = OSDParser.DeserializeJson(data);
Deserialize(osdata);
}
public void Deserialize(OSD osdata)
{
if (osdata.Type == OSDType.Map)
{
OSDMap map = (OSDMap)osdata;
ID = map["id"].AsUUID();
Name = map["name"].AsString();
Description = map["description"].AsString();
CreationDate = map["creation_date"].AsDate();
ContentType = map["type"].AsString();
SHA1 = map["sha1"].AsBinary();
Temporary = map["temporary"].AsBoolean();
OSDMap methods = map["methods"] as OSDMap;
if (methods != null)
{
foreach (KeyValuePair<string, OSD> kvp in methods)
Methods.Add(kvp.Key, kvp.Value.AsUri());
}
ExtraData = map["extra_data"] as OSDMap;
}
}
}
}
using System;
using System.Collections.Generic;
using System.Xml;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
namespace OpenSim.Grid.AssetInventoryServer
{
public class Metadata
{
public UUID ID;
public string Name;
public string Description;
public DateTime CreationDate;
public string ContentType;
public byte[] SHA1;
public bool Temporary;
public Dictionary<string, Uri> Methods = new Dictionary<string, Uri>();
public OSDMap ExtraData;
public OSDMap SerializeToOSD()
{
OSDMap osdata = new OSDMap();
if (ID != UUID.Zero) osdata["id"] = OSD.FromUUID(ID);
osdata["name"] = OSD.FromString(Name);
osdata["description"] = OSD.FromString(Description);
osdata["creation_date"] = OSD.FromDate(CreationDate);
osdata["type"] = OSD.FromString(ContentType);
osdata["sha1"] = OSD.FromBinary(SHA1);
osdata["temporary"] = OSD.FromBoolean(Temporary);
OSDMap methods = new OSDMap(Methods.Count);
foreach (KeyValuePair<string, Uri> kvp in Methods)
methods.Add(kvp.Key, OSD.FromUri(kvp.Value));
osdata["methods"] = methods;
if (ExtraData != null) osdata["extra_data"] = ExtraData;
return osdata;
}
public byte[] SerializeToBytes()
{
LitJson.JsonData jsonData = OSDParser.SerializeJson(SerializeToOSD());
return System.Text.Encoding.UTF8.GetBytes(jsonData.ToJson());
}
public void Deserialize(byte[] data)
{
OSD osdata = OSDParser.DeserializeJson(System.Text.Encoding.UTF8.GetString(data));
Deserialize(osdata);
}
public void Deserialize(string data)
{
OSD osdata = OSDParser.DeserializeJson(data);
Deserialize(osdata);
}
public void Deserialize(OSD osdata)
{
if (osdata.Type == OSDType.Map)
{
OSDMap map = (OSDMap)osdata;
ID = map["id"].AsUUID();
Name = map["name"].AsString();
Description = map["description"].AsString();
CreationDate = map["creation_date"].AsDate();
ContentType = map["type"].AsString();
SHA1 = map["sha1"].AsBinary();
Temporary = map["temporary"].AsBoolean();
OSDMap methods = map["methods"] as OSDMap;
if (methods != null)
{
foreach (KeyValuePair<string, OSD> kvp in methods)
Methods.Add(kvp.Key, kvp.Value.AsUri());
}
ExtraData = map["extra_data"] as OSDMap;
}
}
}
}

480
OpenSim/Grid/AssetInventoryServer/Plugins/OpenSim/OpenSimAssetFrontendPlugin.cs
View File

@ -1,240 +1,240 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Xml;
using ExtensionLoader;
using OpenMetaverse;
using HttpServer;
using OpenSim.Framework;
namespace OpenSim.Grid.AssetInventoryServer.Plugins
{
public class OpenSimAssetFrontendPlugin : IAssetInventoryServerPlugin
{
AssetInventoryServer server;
public OpenSimAssetFrontendPlugin()
{
}
#region IPlugin implementation
public void Initialise(AssetInventoryServer server)
{
this.server = server;
// Asset request
server.HttpServer.AddHandler("get", null, @"^/assets/", AssetRequestHandler);
// Asset creation
server.HttpServer.AddHandler("post", null, @"^/assets/", AssetPostHandler);
}
/// <summary>
/// <para>Initialises asset interface</para>
/// </summary>
public void Initialise()
{
Logger.Log.InfoFormat("[ASSET]: {0} cannot be default-initialized!", Name);
throw new PluginNotInitialisedException(Name);
}
public void Dispose()
{
}
public string Version
{
// TODO: this should be something meaningful and not hardcoded?
get { return "0.1"; }
}
public string Name
{
get { return "AssetInventoryServer OpenSim asset frontend"; }
}
#endregion IPlugin implementation
bool AssetRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up to get the asset ID out
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && rawUrl[2].Length >= 36 && UUID.TryParse(rawUrl[2].Substring(0, 36), out assetID))
{
Metadata metadata;
byte[] assetData;
BackendResponse dataResponse;
if ((dataResponse = server.StorageProvider.TryFetchDataMetadata(assetID, out metadata, out assetData)) == BackendResponse.Success)
{
MemoryStream stream = new MemoryStream();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create(stream, settings);
writer.WriteStartDocument();
writer.WriteStartElement("AssetBase");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
writer.WriteStartElement("FullID");
writer.WriteStartElement("Guid");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteStartElement("ID");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Data");
writer.WriteBase64(assetData, 0, assetData.Length);
writer.WriteEndElement();
writer.WriteStartElement("Type");
writer.WriteValue(Utils.ContentTypeToSLAssetType(metadata.ContentType));
writer.WriteEndElement();
writer.WriteStartElement("Name");
writer.WriteString(metadata.Name);
writer.WriteEndElement();
writer.WriteStartElement("Description");
writer.WriteString(metadata.Description);
writer.WriteEndElement();
writer.WriteStartElement("Local");
writer.WriteValue(false);
writer.WriteEndElement();
writer.WriteStartElement("Temporary");
writer.WriteValue(metadata.Temporary);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
byte[] buffer = stream.GetBuffer();
response.Status = HttpStatusCode.OK;
response.ContentType = "application/xml";
response.ContentLength = stream.Length;
response.Body.Write(buffer, 0, (int)stream.Length);
response.Body.Flush();
}
else
{
Logger.Log.WarnFormat("Failed to fetch asset data or metadata for {0}: {1}", assetID, dataResponse);
response.Status = HttpStatusCode.NotFound;
}
}
else
{
Logger.Log.Warn("Unrecognized OpenSim asset request: " + request.Uri.PathAndQuery);
}
return true;
}
bool AssetPostHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = null;
Metadata metadata = new Metadata();
Logger.Log.Debug("Handling OpenSim asset upload");
try
{
using (XmlReader reader = XmlReader.Create(request.Body))
{
reader.MoveToContent();
reader.ReadStartElement("AssetBase");
reader.ReadStartElement("FullID");
UUID.TryParse(reader.ReadElementContentAsString("Guid", String.Empty), out metadata.ID);
reader.ReadEndElement();
reader.ReadStartElement("ID");
reader.Skip();
reader.ReadEndElement();
// HACK: Broken on Mono. https://bugzilla.novell.com/show_bug.cgi?id=464229
//int readBytes = 0;
//byte[] buffer = new byte[1024];
//MemoryStream stream = new MemoryStream();
//BinaryWriter writer = new BinaryWriter(stream);
//while ((readBytes = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length)) > 0)
// writer.Write(buffer, 0, readBytes);
//writer.Flush();
//assetData = stream.GetBuffer();
//Array.Resize<byte>(ref assetData, (int)stream.Length);
assetData = Convert.FromBase64String(reader.ReadElementContentAsString());
int type;
Int32.TryParse(reader.ReadElementContentAsString("Type", String.Empty), out type);
metadata.ContentType = Utils.SLAssetTypeToContentType(type);
metadata.Name = reader.ReadElementContentAsString("Name", String.Empty);
metadata.Description = reader.ReadElementContentAsString("Description", String.Empty);
Boolean.TryParse(reader.ReadElementContentAsString("Local", String.Empty), out metadata.Temporary);
Boolean.TryParse(reader.ReadElementContentAsString("Temporary", String.Empty), out metadata.Temporary);
reader.ReadEndElement();
}
if (assetData != null && assetData.Length > 0)
{
metadata.SHA1 = OpenMetaverse.Utils.SHA1(assetData);
metadata.CreationDate = DateTime.Now;
BackendResponse storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData);
if (storageResponse == BackendResponse.Success)
response.Status = HttpStatusCode.Created;
else if (storageResponse == BackendResponse.NotFound)
response.Status = HttpStatusCode.NotFound;
else
response.Status = HttpStatusCode.InternalServerError;
}
else
{
Logger.Log.Warn("AssetPostHandler called with no asset data");
response.Status = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
Logger.Log.Warn("Failed to parse POST data (expecting AssetBase): " + ex.Message);
response.Status = HttpStatusCode.BadRequest;
}
Logger.Log.Debug("Finished handling OpenSim asset upload, Status: " + response.Status.ToString());
return true;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Xml;
using ExtensionLoader;
using OpenMetaverse;
using HttpServer;
using OpenSim.Framework;
namespace OpenSim.Grid.AssetInventoryServer.Plugins
{
public class OpenSimAssetFrontendPlugin : IAssetInventoryServerPlugin
{
AssetInventoryServer server;
public OpenSimAssetFrontendPlugin()
{
}
#region IPlugin implementation
public void Initialise(AssetInventoryServer server)
{
this.server = server;
// Asset request
server.HttpServer.AddHandler("get", null, @"^/assets/", AssetRequestHandler);
// Asset creation
server.HttpServer.AddHandler("post", null, @"^/assets/", AssetPostHandler);
}
/// <summary>
/// <para>Initialises asset interface</para>
/// </summary>
public void Initialise()
{
Logger.Log.InfoFormat("[ASSET]: {0} cannot be default-initialized!", Name);
throw new PluginNotInitialisedException(Name);
}
public void Dispose()
{
}
public string Version
{
// TODO: this should be something meaningful and not hardcoded?
get { return "0.1"; }
}
public string Name
{
get { return "AssetInventoryServer OpenSim asset frontend"; }
}
#endregion IPlugin implementation
bool AssetRequestHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
UUID assetID;
// Split the URL up to get the asset ID out
string[] rawUrl = request.Uri.PathAndQuery.Split('/');
if (rawUrl.Length >= 3 && rawUrl[2].Length >= 36 && UUID.TryParse(rawUrl[2].Substring(0, 36), out assetID))
{
Metadata metadata;
byte[] assetData;
BackendResponse dataResponse;
if ((dataResponse = server.StorageProvider.TryFetchDataMetadata(assetID, out metadata, out assetData)) == BackendResponse.Success)
{
MemoryStream stream = new MemoryStream();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create(stream, settings);
writer.WriteStartDocument();
writer.WriteStartElement("AssetBase");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
writer.WriteStartElement("FullID");
writer.WriteStartElement("Guid");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteStartElement("ID");
writer.WriteString(assetID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Data");
writer.WriteBase64(assetData, 0, assetData.Length);
writer.WriteEndElement();
writer.WriteStartElement("Type");
writer.WriteValue(Utils.ContentTypeToSLAssetType(metadata.ContentType));
writer.WriteEndElement();
writer.WriteStartElement("Name");
writer.WriteString(metadata.Name);
writer.WriteEndElement();
writer.WriteStartElement("Description");
writer.WriteString(metadata.Description);
writer.WriteEndElement();
writer.WriteStartElement("Local");
writer.WriteValue(false);
writer.WriteEndElement();
writer.WriteStartElement("Temporary");
writer.WriteValue(metadata.Temporary);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
byte[] buffer = stream.GetBuffer();
response.Status = HttpStatusCode.OK;
response.ContentType = "application/xml";
response.ContentLength = stream.Length;
response.Body.Write(buffer, 0, (int)stream.Length);
response.Body.Flush();
}
else
{
Logger.Log.WarnFormat("Failed to fetch asset data or metadata for {0}: {1}", assetID, dataResponse);
response.Status = HttpStatusCode.NotFound;
}
}
else
{
Logger.Log.Warn("Unrecognized OpenSim asset request: " + request.Uri.PathAndQuery);
}
return true;
}
bool AssetPostHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = null;
Metadata metadata = new Metadata();
Logger.Log.Debug("Handling OpenSim asset upload");
try
{
using (XmlReader reader = XmlReader.Create(request.Body))
{
reader.MoveToContent();
reader.ReadStartElement("AssetBase");
reader.ReadStartElement("FullID");
UUID.TryParse(reader.ReadElementContentAsString("Guid", String.Empty), out metadata.ID);
reader.ReadEndElement();
reader.ReadStartElement("ID");
reader.Skip();
reader.ReadEndElement();
// HACK: Broken on Mono. https://bugzilla.novell.com/show_bug.cgi?id=464229
//int readBytes = 0;
//byte[] buffer = new byte[1024];
//MemoryStream stream = new MemoryStream();
//BinaryWriter writer = new BinaryWriter(stream);
//while ((readBytes = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length)) > 0)
// writer.Write(buffer, 0, readBytes);
//writer.Flush();
//assetData = stream.GetBuffer();
//Array.Resize<byte>(ref assetData, (int)stream.Length);
assetData = Convert.FromBase64String(reader.ReadElementContentAsString());
int type;
Int32.TryParse(reader.ReadElementContentAsString("Type", String.Empty), out type);
metadata.ContentType = Utils.SLAssetTypeToContentType(type);
metadata.Name = reader.ReadElementContentAsString("Name", String.Empty);
metadata.Description = reader.ReadElementContentAsString("Description", String.Empty);
Boolean.TryParse(reader.ReadElementContentAsString("Local", String.Empty), out metadata.Temporary);
Boolean.TryParse(reader.ReadElementContentAsString("Temporary", String.Empty), out metadata.Temporary);
reader.ReadEndElement();
}
if (assetData != null && assetData.Length > 0)
{
metadata.SHA1 = OpenMetaverse.Utils.SHA1(assetData);
metadata.CreationDate = DateTime.Now;
BackendResponse storageResponse = server.StorageProvider.TryCreateAsset(metadata, assetData);
if (storageResponse == BackendResponse.Success)
response.Status = HttpStatusCode.Created;
else if (storageResponse == BackendResponse.NotFound)
response.Status = HttpStatusCode.NotFound;
else
response.Status = HttpStatusCode.InternalServerError;
}
else
{
Logger.Log.Warn("AssetPostHandler called with no asset data");
response.Status = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
Logger.Log.Warn("Failed to parse POST data (expecting AssetBase): " + ex.Message);
response.Status = HttpStatusCode.BadRequest;
}
Logger.Log.Debug("Finished handling OpenSim asset upload, Status: " + response.Status.ToString());
return true;
}
}
}

740
OpenSim/Grid/AssetInventoryServer/Plugins/OpenSim/OpenSimAssetStoragePlugin.cs
View File

@ -1,370 +1,370 @@
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Data;
using MySql.Data.MySqlClient;
using ExtensionLoader;
using ExtensionLoader.Config;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using OpenSim.Framework;
using OpenSim.Grid.AssetInventoryServer.Extensions;
namespace OpenSim.Grid.AssetInventoryServer.Plugins
{
public class OpenSimAssetStoragePlugin : IAssetStorageProvider
{
const string EXTENSION_NAME = "OpenSimAssetStorage"; // Used in metrics reporting
private AssetInventoryServer server;
private IAssetProviderPlugin m_assetProvider;
public OpenSimAssetStoragePlugin()
{
}
#region IAssetStorageProvider implementation
public BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata)
{
metadata = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.ID = assetID;
metadata.Name = reader.GetString(0);
metadata.Description = reader.GetString(1);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
metadata.Temporary = reader.GetBoolean(3);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
return ret;
}
public BackendResponse TryFetchData(UUID assetID, out byte[] assetData)
{
assetData = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT data FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
assetData = (byte[])reader.GetValue(0);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData)
{
metadata = null;
assetData = null;
//BackendResponse ret;
AssetBase asset_base = m_assetProvider.FetchAsset(assetID);
if (asset_base != null)
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.Name = asset_base.Name;
metadata.Description = asset_base.Description;
metadata.ContentType = Utils.SLAssetTypeToContentType(asset_base.Type);
metadata.Temporary = asset_base.Temporary;
assetData = asset_base.Data;
}
else return BackendResponse.NotFound;
return BackendResponse.Success;
//using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
//{
// IDataReader reader;
// try
// {
// dbConnection.Open();
// IDbCommand command = dbConnection.CreateCommand();
// command.CommandText = String.Format("SELECT name,description,assetType,temporary,data FROM assets WHERE id='{0}'", assetID.ToString());
// reader = command.ExecuteReader();
// if (reader.Read())
// {
// metadata = new Metadata();
// metadata.CreationDate = OpenMetaverse.Utils.Epoch;
// metadata.SHA1 = null;
// metadata.ID = assetID;
// metadata.Name = reader.GetString(0);
// metadata.Description = reader.GetString(1);
// metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
// metadata.Temporary = reader.GetBoolean(3);
// assetData = (byte[])reader.GetValue(4);
// ret = BackendResponse.Success;
// }
// else
// {
// ret = BackendResponse.NotFound;
// }
// }
// catch (MySqlException ex)
// {
// Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
// ret = BackendResponse.Failure;
// }
//}
//server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
//server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
//return ret;
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID)
{
assetID = metadata.ID = UUID.Random();
return TryCreateAsset(metadata, assetData);
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData)
{
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
try
{
dbConnection.Open();
MySqlCommand command = new MySqlCommand(
"REPLACE INTO assets (name,description,assetType,local,temporary,data,id) VALUES " +
"(?name,?description,?assetType,?local,?temporary,?data,?id)", dbConnection);
command.Parameters.AddWithValue("?name", metadata.Name);
command.Parameters.AddWithValue("?description", metadata.Description);
command.Parameters.AddWithValue("?assetType", Utils.ContentTypeToSLAssetType(metadata.ContentType));
command.Parameters.AddWithValue("?local", 0);
command.Parameters.AddWithValue("?temporary", metadata.Temporary);
command.Parameters.AddWithValue("?data", assetData);
command.Parameters.AddWithValue("?id", metadata.ID.ToString());
int rowsAffected = command.ExecuteNonQuery();
if (rowsAffected == 1)
{
ret = BackendResponse.Success;
}
else if (rowsAffected == 2)
{
Logger.Log.Info("Replaced asset " + metadata.ID.ToString());
ret = BackendResponse.Success;
}
else
{
Logger.Log.ErrorFormat("MySQL REPLACE query affected {0} rows", rowsAffected);
ret = BackendResponse.Failure;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetCreate(EXTENSION_NAME, ret, metadata.ID, assetData.Length, DateTime.Now);
return ret;
}
public int ForEach(Action<Metadata> action, int start, int count)
{
int rowCount = 0;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
MySqlDataReader reader;
try
{
dbConnection.Open();
MySqlCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary,data,id FROM assets LIMIT {0}, {1}",
start, count);
reader = command.ExecuteReader();
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
return 0;
}
while (reader.Read())
{
Metadata metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.Description = reader.GetString(1);
metadata.ID = UUID.Parse(reader.GetString(5));
metadata.Name = reader.GetString(0);
metadata.SHA1 = OpenMetaverse.Utils.SHA1((byte[])reader.GetValue(4));
metadata.Temporary = reader.GetBoolean(3);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
action(metadata);
++rowCount;
}
reader.Close();
}
return rowCount;
}
#endregion IAssetStorageProvider implementation
#region IPlugin implementation
public void Initialise(AssetInventoryServer server)
{
this.server = server;
try
{
m_assetProvider = LoadDatabasePlugin("OpenSim.Data.MySQL.dll", server.ConfigFile.Configs["MySQL"].GetString("database_connect", null));
if (m_assetProvider == null)
{
Logger.Log.Error("[ASSET]: Failed to load a database plugin, server halting.");
Environment.Exit(-1);
}
else
Logger.Log.InfoFormat("[ASSET]: Loaded storage backend: {0}", Version);
}
catch (Exception e)
{
Logger.Log.WarnFormat("[ASSET]: Failure loading data plugin: {0}", e.ToString());
}
}
/// <summary>
/// <para>Initialises asset interface</para>
/// </summary>
public void Initialise()
{
Logger.Log.InfoFormat("[ASSET]: {0} cannot be default-initialized!", Name);
throw new PluginNotInitialisedException(Name);
}
public void Dispose()
{
}
public string Version
{
get { return m_assetProvider.Version; }
}
public string Name
{
get { return "AssetInventoryServer OpenSim asset storage provider"; }
}
#endregion IPlugin implementation
private IAssetProviderPlugin LoadDatabasePlugin(string provider, string connect)
{
PluginLoader<IAssetProviderPlugin> loader = new PluginLoader<IAssetProviderPlugin>(new AssetDataInitialiser(connect));
// Loader will try to load all providers (MySQL, MSSQL, etc)
// unless it is constrainted to the correct "Provider" entry in the addin.xml
loader.Add("/OpenSim/AssetData", new PluginProviderFilter (provider));
loader.Load();
return loader.Plugin;
}
}
}
/*
* Copyright (c) 2008 Intel Corporation
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* -- Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* -- Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* -- Neither the name of the Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Data;
using MySql.Data.MySqlClient;
using ExtensionLoader;
using ExtensionLoader.Config;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using OpenSim.Framework;
using OpenSim.Grid.AssetInventoryServer.Extensions;
namespace OpenSim.Grid.AssetInventoryServer.Plugins
{
public class OpenSimAssetStoragePlugin : IAssetStorageProvider
{
const string EXTENSION_NAME = "OpenSimAssetStorage"; // Used in metrics reporting
private AssetInventoryServer server;
private IAssetProviderPlugin m_assetProvider;
public OpenSimAssetStoragePlugin()
{
}
#region IAssetStorageProvider implementation
public BackendResponse TryFetchMetadata(UUID assetID, out Metadata metadata)
{
metadata = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.ID = assetID;
metadata.Name = reader.GetString(0);
metadata.Description = reader.GetString(1);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
metadata.Temporary = reader.GetBoolean(3);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
return ret;
}
public BackendResponse TryFetchData(UUID assetID, out byte[] assetData)
{
assetData = null;
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
IDataReader reader;
try
{
dbConnection.Open();
IDbCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT data FROM assets WHERE id='{0}'", assetID.ToString());
reader = command.ExecuteReader();
if (reader.Read())
{
assetData = (byte[])reader.GetValue(0);
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
return ret;
}
public BackendResponse TryFetchDataMetadata(UUID assetID, out Metadata metadata, out byte[] assetData)
{
metadata = null;
assetData = null;
//BackendResponse ret;
AssetBase asset_base = m_assetProvider.FetchAsset(assetID);
if (asset_base != null)
{
metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.SHA1 = null;
metadata.Name = asset_base.Name;
metadata.Description = asset_base.Description;
metadata.ContentType = Utils.SLAssetTypeToContentType(asset_base.Type);
metadata.Temporary = asset_base.Temporary;
assetData = asset_base.Data;
}
else return BackendResponse.NotFound;
return BackendResponse.Success;
//using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
//{
// IDataReader reader;
// try
// {
// dbConnection.Open();
// IDbCommand command = dbConnection.CreateCommand();
// command.CommandText = String.Format("SELECT name,description,assetType,temporary,data FROM assets WHERE id='{0}'", assetID.ToString());
// reader = command.ExecuteReader();
// if (reader.Read())
// {
// metadata = new Metadata();
// metadata.CreationDate = OpenMetaverse.Utils.Epoch;
// metadata.SHA1 = null;
// metadata.ID = assetID;
// metadata.Name = reader.GetString(0);
// metadata.Description = reader.GetString(1);
// metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
// metadata.Temporary = reader.GetBoolean(3);
// assetData = (byte[])reader.GetValue(4);
// ret = BackendResponse.Success;
// }
// else
// {
// ret = BackendResponse.NotFound;
// }
// }
// catch (MySqlException ex)
// {
// Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
// ret = BackendResponse.Failure;
// }
//}
//server.MetricsProvider.LogAssetMetadataFetch(EXTENSION_NAME, ret, assetID, DateTime.Now);
//server.MetricsProvider.LogAssetDataFetch(EXTENSION_NAME, ret, assetID, (assetData != null ? assetData.Length : 0), DateTime.Now);
//return ret;
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData, out UUID assetID)
{
assetID = metadata.ID = UUID.Random();
return TryCreateAsset(metadata, assetData);
}
public BackendResponse TryCreateAsset(Metadata metadata, byte[] assetData)
{
BackendResponse ret;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
try
{
dbConnection.Open();
MySqlCommand command = new MySqlCommand(
"REPLACE INTO assets (name,description,assetType,local,temporary,data,id) VALUES " +
"(?name,?description,?assetType,?local,?temporary,?data,?id)", dbConnection);
command.Parameters.AddWithValue("?name", metadata.Name);
command.Parameters.AddWithValue("?description", metadata.Description);
command.Parameters.AddWithValue("?assetType", Utils.ContentTypeToSLAssetType(metadata.ContentType));
command.Parameters.AddWithValue("?local", 0);
command.Parameters.AddWithValue("?temporary", metadata.Temporary);
command.Parameters.AddWithValue("?data", assetData);
command.Parameters.AddWithValue("?id", metadata.ID.ToString());
int rowsAffected = command.ExecuteNonQuery();
if (rowsAffected == 1)
{
ret = BackendResponse.Success;
}
else if (rowsAffected == 2)
{
Logger.Log.Info("Replaced asset " + metadata.ID.ToString());
ret = BackendResponse.Success;
}
else
{
Logger.Log.ErrorFormat("MySQL REPLACE query affected {0} rows", rowsAffected);
ret = BackendResponse.Failure;
}
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
ret = BackendResponse.Failure;
}
}
server.MetricsProvider.LogAssetCreate(EXTENSION_NAME, ret, metadata.ID, assetData.Length, DateTime.Now);
return ret;
}
public int ForEach(Action<Metadata> action, int start, int count)
{
int rowCount = 0;
using (MySqlConnection dbConnection = new MySqlConnection(DBConnString.GetConnectionString(server.ConfigFile)))
{
MySqlDataReader reader;
try
{
dbConnection.Open();
MySqlCommand command = dbConnection.CreateCommand();
command.CommandText = String.Format("SELECT name,description,assetType,temporary,data,id FROM assets LIMIT {0}, {1}",
start, count);
reader = command.ExecuteReader();
}
catch (MySqlException ex)
{
Logger.Log.Error("Connection to MySQL backend failed: " + ex.Message);
return 0;
}
while (reader.Read())
{
Metadata metadata = new Metadata();
metadata.CreationDate = OpenMetaverse.Utils.Epoch;
metadata.Description = reader.GetString(1);
metadata.ID = UUID.Parse(reader.GetString(5));
metadata.Name = reader.GetString(0);
metadata.SHA1 = OpenMetaverse.Utils.SHA1((byte[])reader.GetValue(4));
metadata.Temporary = reader.GetBoolean(3);
metadata.ContentType = Utils.SLAssetTypeToContentType(reader.GetInt32(2));
action(metadata);
++rowCount;
}
reader.Close();
}
return rowCount;
}
#endregion IAssetStorageProvider implementation
#region IPlugin implementation
public void Initialise(AssetInventoryServer server)
{
this.server = server;
try
{
m_assetProvider = LoadDatabasePlugin("OpenSim.Data.MySQL.dll", server.ConfigFile.Configs["MySQL"].GetString("database_connect", null));
if (m_assetProvider == null)
{
Logger.Log.Error("[ASSET]: Failed to load a database plugin, server halting.");
Environment.Exit(-1);
}
else
Logger.Log.InfoFormat("[ASSET]: Loaded storage backend: {0}", Version);
}
catch (Exception e)
{
Logger.Log.WarnFormat("[ASSET]: Failure loading data plugin: {0}", e.ToString());
}
}
/// <summary>
/// <para>Initialises asset interface</para>
/// </summary>
public void Initialise()
{
Logger.Log.InfoFormat("[ASSET]: {0} cannot be default-initialized!", Name);
throw new PluginNotInitialisedException(Name);
}
public void Dispose()
{
}
public string Version
{
get { return m_assetProvider.Version; }
}
public string Name
{
get { return "AssetInventoryServer OpenSim asset storage provider"; }
}
#endregion IPlugin implementation
private IAssetProviderPlugin LoadDatabasePlugin(string provider, string connect)
{
PluginLoader<IAssetProviderPlugin> loader = new PluginLoader<IAssetProviderPlugin>(new AssetDataInitialiser(connect));
// Loader will try to load all providers (MySQL, MSSQL, etc)
// unless it is constrainted to the correct "Provider" entry in the addin.xml
loader.Add("/OpenSim/AssetData", new PluginProviderFilter (provider));
loader.Load();
return loader.Plugin;
}
}
}

2068
OpenSim/Grid/AssetInventoryServer/Utils.cs
View File

File diff suppressed because it is too large Load Diff