fix line endings

afrisby
Sean Dague 2007-10-25 15:43:48 +00:00
parent 32869aec47
commit 461eaf188e
3 changed files with 623 additions and 623 deletions

View File

@ -1,163 +1,163 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace OpenSim.Framework.RestClient
{
internal class SimpleAsyncResult : IAsyncResult
{
private readonly AsyncCallback m_callback;
/// <summary>
/// Is process completed?
/// </summary>
/// <remarks>Should really be boolean, but VolatileRead has no boolean method</remarks>
private byte m_completed;
/// <summary>
/// Did process complete synchroneously?
/// </summary>
/// <remarks>I have a hard time imagining a scenario where this is the case, again, same issue about
/// booleans and VolatileRead as m_completed
/// </remarks>
private byte m_completedSynchronously;
private readonly object m_asyncState;
private ManualResetEvent m_waitHandle;
private Exception m_exception;
internal SimpleAsyncResult(AsyncCallback cb, object state)
{
m_callback = cb;
m_asyncState = state;
m_completed = 0;
m_completedSynchronously = 1;
}
#region IAsyncResult Members
public object AsyncState
{
get { return m_asyncState; }
}
public WaitHandle AsyncWaitHandle
{
get
{
if (m_waitHandle == null)
{
bool done = IsCompleted;
ManualResetEvent mre = new ManualResetEvent(done);
if (Interlocked.CompareExchange(ref m_waitHandle, mre, null) != null)
{
mre.Close();
}
else
{
if (!done && IsCompleted)
{
m_waitHandle.Set();
}
}
}
return m_waitHandle;
}
}
public bool CompletedSynchronously
{
get { return Thread.VolatileRead(ref m_completedSynchronously) == 1; }
}
public bool IsCompleted
{
get { return Thread.VolatileRead(ref m_completed) == 1; }
}
#endregion
#region class Methods
internal void SetAsCompleted(bool completedSynchronously)
{
m_completed = 1;
if(completedSynchronously)
m_completedSynchronously = 1;
else
m_completedSynchronously = 0;
SignalCompletion();
}
internal void HandleException(Exception e, bool completedSynchronously)
{
m_completed = 1;
if (completedSynchronously)
m_completedSynchronously = 1;
else
m_completedSynchronously = 0;
m_exception = e;
SignalCompletion();
}
private void SignalCompletion()
{
if(m_waitHandle != null) m_waitHandle.Set();
if(m_callback != null) m_callback(this);
}
public void EndInvoke()
{
// This method assumes that only 1 thread calls EndInvoke
if (!IsCompleted)
{
// If the operation isn't done, wait for it
AsyncWaitHandle.WaitOne();
AsyncWaitHandle.Close();
m_waitHandle = null; // Allow early GC
}
// Operation is done: if an exception occured, throw it
if (m_exception != null) throw m_exception;
}
#endregion
}
internal class AsyncResult<T> : SimpleAsyncResult
{
private T m_result = default(T);
public AsyncResult(AsyncCallback asyncCallback, Object state) :
base(asyncCallback, state) { }
public void SetAsCompleted(T result, bool completedSynchronously)
{
// Save the asynchronous operation's result
m_result = result;
// Tell the base class that the operation completed
// sucessfully (no exception)
base.SetAsCompleted(completedSynchronously);
}
new public T EndInvoke()
{
base.EndInvoke();
return m_result;
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace OpenSim.Framework.RestClient
{
internal class SimpleAsyncResult : IAsyncResult
{
private readonly AsyncCallback m_callback;
/// <summary>
/// Is process completed?
/// </summary>
/// <remarks>Should really be boolean, but VolatileRead has no boolean method</remarks>
private byte m_completed;
/// <summary>
/// Did process complete synchroneously?
/// </summary>
/// <remarks>I have a hard time imagining a scenario where this is the case, again, same issue about
/// booleans and VolatileRead as m_completed
/// </remarks>
private byte m_completedSynchronously;
private readonly object m_asyncState;
private ManualResetEvent m_waitHandle;
private Exception m_exception;
internal SimpleAsyncResult(AsyncCallback cb, object state)
{
m_callback = cb;
m_asyncState = state;
m_completed = 0;
m_completedSynchronously = 1;
}
#region IAsyncResult Members
public object AsyncState
{
get { return m_asyncState; }
}
public WaitHandle AsyncWaitHandle
{
get
{
if (m_waitHandle == null)
{
bool done = IsCompleted;
ManualResetEvent mre = new ManualResetEvent(done);
if (Interlocked.CompareExchange(ref m_waitHandle, mre, null) != null)
{
mre.Close();
}
else
{
if (!done && IsCompleted)
{
m_waitHandle.Set();
}
}
}
return m_waitHandle;
}
}
public bool CompletedSynchronously
{
get { return Thread.VolatileRead(ref m_completedSynchronously) == 1; }
}
public bool IsCompleted
{
get { return Thread.VolatileRead(ref m_completed) == 1; }
}
#endregion
#region class Methods
internal void SetAsCompleted(bool completedSynchronously)
{
m_completed = 1;
if(completedSynchronously)
m_completedSynchronously = 1;
else
m_completedSynchronously = 0;
SignalCompletion();
}
internal void HandleException(Exception e, bool completedSynchronously)
{
m_completed = 1;
if (completedSynchronously)
m_completedSynchronously = 1;
else
m_completedSynchronously = 0;
m_exception = e;
SignalCompletion();
}
private void SignalCompletion()
{
if(m_waitHandle != null) m_waitHandle.Set();
if(m_callback != null) m_callback(this);
}
public void EndInvoke()
{
// This method assumes that only 1 thread calls EndInvoke
if (!IsCompleted)
{
// If the operation isn't done, wait for it
AsyncWaitHandle.WaitOne();
AsyncWaitHandle.Close();
m_waitHandle = null; // Allow early GC
}
// Operation is done: if an exception occured, throw it
if (m_exception != null) throw m_exception;
}
#endregion
}
internal class AsyncResult<T> : SimpleAsyncResult
{
private T m_result = default(T);
public AsyncResult(AsyncCallback asyncCallback, Object state) :
base(asyncCallback, state) { }
public void SetAsCompleted(T result, bool completedSynchronously)
{
// Save the asynchronous operation's result
m_result = result;
// Tell the base class that the operation completed
// sucessfully (no exception)
base.SetAsCompleted(completedSynchronously);
}
new public T EndInvoke()
{
base.EndInvoke();
return m_result;
}
}
}

View File

@ -1,328 +1,328 @@
using System;
using System.IO;
using System.Net;
using System.Web;
using System.Text;
using System.Collections.Generic;
using System.Threading;
namespace OpenSim.Framework.RestClient
{
/// <summary>
/// Implementation of a generic REST client
/// </summary>
/// <remarks>
/// This class is a generic implementation of a REST (Representational State Transfer) web service. This
/// class is designed to execute both synchroneously and asynchroneously.
///
/// Internally the implementation works as a two stage asynchroneous web-client.
/// When the request is initiated, RestClient will query asynchroneously for for a web-response,
/// sleeping until the initial response is returned by the server. Once the initial response is retrieved
/// the second stage of asynchroneous requests will be triggered, in an attempt to read of the response
/// object into a memorystream as a sequence of asynchroneous reads.
///
/// The asynchronisity of RestClient is designed to move as much processing into the back-ground, allowing
/// other threads to execute, while it waits for a response from the web-service. RestClient it self, can be
/// invoked by the caller in either synchroneous mode or asynchroneous mode.
/// </remarks>
public class RestClient
{
/// <summary>
/// The base Uri of the web-service e.g. http://www.google.com
/// </summary>
private string _url;
/// <summary>
/// Path elements of the query
/// </summary>
private List<string> _pathElements = new List<string>();
/// <summary>
/// Parameter elements of the query, e.g. min=34
/// </summary>
private Dictionary<string, string> _parameterElements = new Dictionary<string, string>();
/// <summary>
/// Request method. E.g. GET, POST, PUT or DELETE
/// </summary>
private string _method;
/// <summary>
/// Temporary buffer used to store bytes temporarily as they come in from the server
/// </summary>
private byte[] _readbuf;
/// <summary>
/// MemoryStream representing the resultiong resource
/// </summary>
MemoryStream _resource;
/// <summary>
/// WebRequest object, held as a member variable
/// </summary>
private HttpWebRequest _request;
/// <summary>
/// WebResponse object, held as a member variable, so we can close it
/// </summary>
private HttpWebResponse _response;
/// <summary>
/// This flag will help block the main synchroneous method, in case we run in synchroneous mode
/// </summary>
public static ManualResetEvent _allDone = new ManualResetEvent(false);
/// <summary>
/// Default time out period
/// </summary>
const int DefaultTimeout = 10 * 1000; // 10 seconds timeout
/// <summary>
/// Default Buffer size of a block requested from the web-server
/// </summary>
const int BufferSize = 4096; // Read blocks of 4 KB.
/// <summary>
/// if an exception occours during async processing, we need to save it, so it can be
/// rethrown on the primary thread;
/// </summary>
private Exception _asyncException;
/// <summary>
/// Instantiate a new RestClient
/// </summary>
/// <param name="url">Web-service to query, e.g. http://osgrid.org:8003</param>
public RestClient(string url)
{
_url = url;
_readbuf = new byte[BufferSize];
_resource = new MemoryStream();
_request = null;
_response = null;
}
/// <summary>
/// Add a path element to the query, e.g. assets
/// </summary>
/// <param name="element">path entry</param>
public void AddResourcePath(string element)
{
if(isSlashed(element))
_pathElements.Add(element.Substring(0, element.Length-1));
else
_pathElements.Add(element);
}
/// <summary>
/// Add a query parameter to the Url
/// </summary>
/// <param name="name">Name of the parameter, e.g. min</param>
/// <param name="value">Value of the parameter, e.g. 42</param>
public void AddQueryParameter(string name, string value)
{
_parameterElements.Add(HttpUtility.UrlEncode(name), HttpUtility.UrlEncode(value));
}
/// <summary>
/// Web-Request method, e.g. GET, PUT, POST, DELETE
/// </summary>
public string RequestMethod
{
get { return _method; }
set { _method = value; }
}
/// <summary>
/// True if string contains a trailing slash '/'
/// </summary>
/// <param name="s">string to be examined</param>
/// <returns>true if slash is present</returns>
private bool isSlashed(string s)
{
return s.Substring(s.Length - 1, 1) == "/";
}
/// <summary>
/// return a slash or blank. A slash will be returned if the string does not contain one
/// </summary>
/// <param name="s">stromg to be examined</param>
/// <returns>slash '/' if not already present</returns>
private string slash(string s)
{
return isSlashed(s) ? "" : "/";
}
/// <summary>
/// Build a Uri based on the intial Url, path elements and parameters
/// </summary>
/// <returns>fully constructed Uri</returns>
Uri buildUri()
{
StringBuilder sb = new StringBuilder();
sb.Append(_url);
foreach (string e in _pathElements)
{
sb.Append("/");
sb.Append(e);
}
bool firstElement = true;
foreach (KeyValuePair<string, string> kv in _parameterElements)
{
if (firstElement)
{
sb.Append("?");
firstElement = false;
} else
sb.Append("&");
sb.Append(kv.Key);
if (kv.Value != null && kv.Value.Length != 0)
{
sb.Append("=");
sb.Append(kv.Value);
}
}
return new Uri(sb.ToString());
}
/// <summary>
/// Async method, invoked when a block of data has been received from the service
/// </summary>
/// <param name="ar"></param>
private void StreamIsReadyDelegate(IAsyncResult ar)
{
try
{
Stream s = (Stream)ar.AsyncState;
int read = s.EndRead(ar);
// Read the HTML page and then print it to the console.
if (read > 0)
{
_resource.Write(_readbuf, 0, read);
IAsyncResult asynchronousResult = s.BeginRead(_readbuf, 0, BufferSize, new AsyncCallback(StreamIsReadyDelegate), s);
// TODO! Implement timeout, without killing the server
//ThreadPool.RegisterWaitForSingleObject(asynchronousResult.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), _request, DefaultTimeout, true);
return;
}
else
{
s.Close();
_allDone.Set();
}
}
catch (Exception e)
{
_allDone.Set();
_asyncException = e;
}
}
/// <summary>
/// Async method, invoked when the intial response if received from the server
/// </summary>
/// <param name="ar"></param>
private void ResponseIsReadyDelegate(IAsyncResult ar)
{
try
{
// grab response
WebRequest wr = (WebRequest)ar.AsyncState;
_response = (HttpWebResponse)wr.EndGetResponse(ar);
// get response stream, and setup async reading
Stream s = _response.GetResponseStream();
IAsyncResult asynchronousResult = s.BeginRead(_readbuf, 0, BufferSize, new AsyncCallback(StreamIsReadyDelegate), s);
// TODO! Implement timeout, without killing the server
// wait until completed, or we timed out
// ThreadPool.RegisterWaitForSingleObject(asynchronousResult.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), _request, DefaultTimeout, true);
}
catch (Exception e)
{
_allDone.Set();
_asyncException = e;
}
}
// Abort the request if the timer fires.
private static void TimeoutCallback(object state, bool timedOut)
{
if (timedOut)
{
HttpWebRequest request = state as HttpWebRequest;
if (request != null)
{
request.Abort();
}
}
}
/// <summary>
/// Perform synchroneous request
/// </summary>
public Stream Request()
{
_request = (HttpWebRequest)WebRequest.Create(buildUri());
_request.KeepAlive = false;
_request.ContentType = "text/html";
_request.Timeout = 200;
_asyncException = null;
IAsyncResult responseAsyncResult = _request.BeginGetResponse(new AsyncCallback(ResponseIsReadyDelegate), _request);
// TODO! Implement timeout, without killing the server
// this line implements the timeout, if there is a timeout, the callback fires and the request becomes aborted
//ThreadPool.RegisterWaitForSingleObject(responseAsyncResult.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), _request, DefaultTimeout, true);
_allDone.WaitOne();
if(_response != null)
_response.Close();
if (_asyncException != null)
throw _asyncException;
return _resource;
}
#region Async Invocation
public IAsyncResult BeginRequest(AsyncCallback callback, object state)
{
/// <summary>
/// In case, we are invoked asynchroneously this object will keep track of the state
/// </summary>
AsyncResult<Stream> ar = new AsyncResult<Stream>(callback, state);
ThreadPool.QueueUserWorkItem(RequestHelper, ar);
return ar;
}
public Stream EndRequest(IAsyncResult asyncResult)
{
AsyncResult<Stream> ar = (AsyncResult<Stream>)asyncResult;
// Wait for operation to complete, then return result or
// throw exception
return ar.EndInvoke();
}
private void RequestHelper(Object asyncResult)
{
// We know that it's really an AsyncResult<DateTime> object
AsyncResult<Stream> ar = (AsyncResult<Stream>)asyncResult;
try
{
// Perform the operation; if sucessful set the result
Stream s = Request();
ar.SetAsCompleted(s, false);
}
catch (Exception e)
{
// If operation fails, set the exception
ar.HandleException(e, false);
}
}
#endregion Async Invocation
}
}
using System;
using System.IO;
using System.Net;
using System.Web;
using System.Text;
using System.Collections.Generic;
using System.Threading;
namespace OpenSim.Framework.RestClient
{
/// <summary>
/// Implementation of a generic REST client
/// </summary>
/// <remarks>
/// This class is a generic implementation of a REST (Representational State Transfer) web service. This
/// class is designed to execute both synchroneously and asynchroneously.
///
/// Internally the implementation works as a two stage asynchroneous web-client.
/// When the request is initiated, RestClient will query asynchroneously for for a web-response,
/// sleeping until the initial response is returned by the server. Once the initial response is retrieved
/// the second stage of asynchroneous requests will be triggered, in an attempt to read of the response
/// object into a memorystream as a sequence of asynchroneous reads.
///
/// The asynchronisity of RestClient is designed to move as much processing into the back-ground, allowing
/// other threads to execute, while it waits for a response from the web-service. RestClient it self, can be
/// invoked by the caller in either synchroneous mode or asynchroneous mode.
/// </remarks>
public class RestClient
{
/// <summary>
/// The base Uri of the web-service e.g. http://www.google.com
/// </summary>
private string _url;
/// <summary>
/// Path elements of the query
/// </summary>
private List<string> _pathElements = new List<string>();
/// <summary>
/// Parameter elements of the query, e.g. min=34
/// </summary>
private Dictionary<string, string> _parameterElements = new Dictionary<string, string>();
/// <summary>
/// Request method. E.g. GET, POST, PUT or DELETE
/// </summary>
private string _method;
/// <summary>
/// Temporary buffer used to store bytes temporarily as they come in from the server
/// </summary>
private byte[] _readbuf;
/// <summary>
/// MemoryStream representing the resultiong resource
/// </summary>
MemoryStream _resource;
/// <summary>
/// WebRequest object, held as a member variable
/// </summary>
private HttpWebRequest _request;
/// <summary>
/// WebResponse object, held as a member variable, so we can close it
/// </summary>
private HttpWebResponse _response;
/// <summary>
/// This flag will help block the main synchroneous method, in case we run in synchroneous mode
/// </summary>
public static ManualResetEvent _allDone = new ManualResetEvent(false);
/// <summary>
/// Default time out period
/// </summary>
const int DefaultTimeout = 10 * 1000; // 10 seconds timeout
/// <summary>
/// Default Buffer size of a block requested from the web-server
/// </summary>
const int BufferSize = 4096; // Read blocks of 4 KB.
/// <summary>
/// if an exception occours during async processing, we need to save it, so it can be
/// rethrown on the primary thread;
/// </summary>
private Exception _asyncException;
/// <summary>
/// Instantiate a new RestClient
/// </summary>
/// <param name="url">Web-service to query, e.g. http://osgrid.org:8003</param>
public RestClient(string url)
{
_url = url;
_readbuf = new byte[BufferSize];
_resource = new MemoryStream();
_request = null;
_response = null;
}
/// <summary>
/// Add a path element to the query, e.g. assets
/// </summary>
/// <param name="element">path entry</param>
public void AddResourcePath(string element)
{
if(isSlashed(element))
_pathElements.Add(element.Substring(0, element.Length-1));
else
_pathElements.Add(element);
}
/// <summary>
/// Add a query parameter to the Url
/// </summary>
/// <param name="name">Name of the parameter, e.g. min</param>
/// <param name="value">Value of the parameter, e.g. 42</param>
public void AddQueryParameter(string name, string value)
{
_parameterElements.Add(HttpUtility.UrlEncode(name), HttpUtility.UrlEncode(value));
}
/// <summary>
/// Web-Request method, e.g. GET, PUT, POST, DELETE
/// </summary>
public string RequestMethod
{
get { return _method; }
set { _method = value; }
}
/// <summary>
/// True if string contains a trailing slash '/'
/// </summary>
/// <param name="s">string to be examined</param>
/// <returns>true if slash is present</returns>
private bool isSlashed(string s)
{
return s.Substring(s.Length - 1, 1) == "/";
}
/// <summary>
/// return a slash or blank. A slash will be returned if the string does not contain one
/// </summary>
/// <param name="s">stromg to be examined</param>
/// <returns>slash '/' if not already present</returns>
private string slash(string s)
{
return isSlashed(s) ? "" : "/";
}
/// <summary>
/// Build a Uri based on the intial Url, path elements and parameters
/// </summary>
/// <returns>fully constructed Uri</returns>
Uri buildUri()
{
StringBuilder sb = new StringBuilder();
sb.Append(_url);
foreach (string e in _pathElements)
{
sb.Append("/");
sb.Append(e);
}
bool firstElement = true;
foreach (KeyValuePair<string, string> kv in _parameterElements)
{
if (firstElement)
{
sb.Append("?");
firstElement = false;
} else
sb.Append("&");
sb.Append(kv.Key);
if (kv.Value != null && kv.Value.Length != 0)
{
sb.Append("=");
sb.Append(kv.Value);
}
}
return new Uri(sb.ToString());
}
/// <summary>
/// Async method, invoked when a block of data has been received from the service
/// </summary>
/// <param name="ar"></param>
private void StreamIsReadyDelegate(IAsyncResult ar)
{
try
{
Stream s = (Stream)ar.AsyncState;
int read = s.EndRead(ar);
// Read the HTML page and then print it to the console.
if (read > 0)
{
_resource.Write(_readbuf, 0, read);
IAsyncResult asynchronousResult = s.BeginRead(_readbuf, 0, BufferSize, new AsyncCallback(StreamIsReadyDelegate), s);
// TODO! Implement timeout, without killing the server
//ThreadPool.RegisterWaitForSingleObject(asynchronousResult.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), _request, DefaultTimeout, true);
return;
}
else
{
s.Close();
_allDone.Set();
}
}
catch (Exception e)
{
_allDone.Set();
_asyncException = e;
}
}
/// <summary>
/// Async method, invoked when the intial response if received from the server
/// </summary>
/// <param name="ar"></param>
private void ResponseIsReadyDelegate(IAsyncResult ar)
{
try
{
// grab response
WebRequest wr = (WebRequest)ar.AsyncState;
_response = (HttpWebResponse)wr.EndGetResponse(ar);
// get response stream, and setup async reading
Stream s = _response.GetResponseStream();
IAsyncResult asynchronousResult = s.BeginRead(_readbuf, 0, BufferSize, new AsyncCallback(StreamIsReadyDelegate), s);
// TODO! Implement timeout, without killing the server
// wait until completed, or we timed out
// ThreadPool.RegisterWaitForSingleObject(asynchronousResult.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), _request, DefaultTimeout, true);
}
catch (Exception e)
{
_allDone.Set();
_asyncException = e;
}
}
// Abort the request if the timer fires.
private static void TimeoutCallback(object state, bool timedOut)
{
if (timedOut)
{
HttpWebRequest request = state as HttpWebRequest;
if (request != null)
{
request.Abort();
}
}
}
/// <summary>
/// Perform synchroneous request
/// </summary>
public Stream Request()
{
_request = (HttpWebRequest)WebRequest.Create(buildUri());
_request.KeepAlive = false;
_request.ContentType = "text/html";
_request.Timeout = 200;
_asyncException = null;
IAsyncResult responseAsyncResult = _request.BeginGetResponse(new AsyncCallback(ResponseIsReadyDelegate), _request);
// TODO! Implement timeout, without killing the server
// this line implements the timeout, if there is a timeout, the callback fires and the request becomes aborted
//ThreadPool.RegisterWaitForSingleObject(responseAsyncResult.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), _request, DefaultTimeout, true);
_allDone.WaitOne();
if(_response != null)
_response.Close();
if (_asyncException != null)
throw _asyncException;
return _resource;
}
#region Async Invocation
public IAsyncResult BeginRequest(AsyncCallback callback, object state)
{
/// <summary>
/// In case, we are invoked asynchroneously this object will keep track of the state
/// </summary>
AsyncResult<Stream> ar = new AsyncResult<Stream>(callback, state);
ThreadPool.QueueUserWorkItem(RequestHelper, ar);
return ar;
}
public Stream EndRequest(IAsyncResult asyncResult)
{
AsyncResult<Stream> ar = (AsyncResult<Stream>)asyncResult;
// Wait for operation to complete, then return result or
// throw exception
return ar.EndInvoke();
}
private void RequestHelper(Object asyncResult)
{
// We know that it's really an AsyncResult<DateTime> object
AsyncResult<Stream> ar = (AsyncResult<Stream>)asyncResult;
try
{
// Perform the operation; if sucessful set the result
Stream s = Request();
ar.SetAsCompleted(s, false);
}
catch (Exception e)
{
// If operation fails, set the exception
ar.HandleException(e, false);
}
}
#endregion Async Invocation
}
}

View File

@ -1,132 +1,132 @@
using System;
using System.Collections.Generic;
using System.Collections;
using System.IO;
using System.Text;
using Nini.Config;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Console;
using OpenSim.Framework.Interfaces;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Types;
using OpenSim.Framework.Utilities;
using OpenSim.Region.ClientStack;
using OpenSim.Region.Communications.Local;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Physics.Manager;
using System.Globalization;
using Nwc.XmlRpc;
using RegionInfo = OpenSim.Framework.Types.RegionInfo;
namespace OpenSim
{
class OpenSimController
{
private OpenSimMain m_app;
private BaseHttpServer m_httpServer;
private const bool m_enablexmlrpc = false;
public OpenSimController(OpenSimMain core, BaseHttpServer httpd)
{
m_app = core;
m_httpServer = httpd;
if (m_enablexmlrpc)
{
m_httpServer.AddXmlRPCHandler("admin_create_region", XmlRpcCreateRegionMethod);
m_httpServer.AddXmlRPCHandler("admin_shutdown", XmlRpcShutdownMethod);
}
}
public XmlRpcResponse XmlRpcShutdownMethod(XmlRpcRequest request)
{
MainLog.Instance.Verbose("CONTROLLER", "Recieved Shutdown Administrator Request");
XmlRpcResponse response = new XmlRpcResponse();
Hashtable requestData = (Hashtable)request.Params[0];
if ((string)requestData["shutdown"] == "delayed")
{
int timeout = Convert.ToInt32((string)requestData["milliseconds"]);
Hashtable responseData = new Hashtable();
responseData["accepted"] = "true";
response.Value = responseData;
m_app.SceneManager.SendGeneralMessage("Region is going down in " + ((int)(timeout / 1000)).ToString() + " second(s). Please save what you are doing and log out.");
// Perform shutdown
System.Timers.Timer shutdownTimer = new System.Timers.Timer(timeout); // Wait before firing
shutdownTimer.AutoReset = false;
shutdownTimer.Elapsed += new System.Timers.ElapsedEventHandler(shutdownTimer_Elapsed);
return response;
}
else
{
Hashtable responseData = new Hashtable();
responseData["accepted"] = "true";
response.Value = responseData;
m_app.SceneManager.SendGeneralMessage("Region is going down now.");
// Perform shutdown
System.Timers.Timer shutdownTimer = new System.Timers.Timer(2000); // Wait 2 seconds before firing
shutdownTimer.AutoReset = false;
shutdownTimer.Elapsed += new System.Timers.ElapsedEventHandler(shutdownTimer_Elapsed);
return response;
}
}
void shutdownTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
m_app.Shutdown();
}
public XmlRpcResponse XmlRpcCreateRegionMethod(XmlRpcRequest request)
{
MainLog.Instance.Verbose("CONTROLLER", "Recieved Create Region Administrator Request");
XmlRpcResponse response = new XmlRpcResponse();
Hashtable requestData = (Hashtable)request.Params[0];
RegionInfo newRegionData = new RegionInfo();
try
{
newRegionData.RegionID = (string)requestData["region_id"];
newRegionData.RegionName = (string)requestData["region_name"];
newRegionData.RegionLocX = Convert.ToUInt32((string)requestData["region_x"]);
newRegionData.RegionLocY = Convert.ToUInt32((string)requestData["region_y"]);
// Security risk
newRegionData.DataStore = (string)requestData["datastore"];
newRegionData.InternalEndPoint = new System.Net.IPEndPoint(
System.Net.IPAddress.Parse((string)requestData["listen_ip"]), 0);
newRegionData.InternalEndPoint.Port = Convert.ToInt32((string)requestData["listen_port"]);
newRegionData.ExternalHostName = (string)requestData["external_address"];
newRegionData.MasterAvatarFirstName = (string)requestData["region_master_first"];
newRegionData.MasterAvatarLastName = (string)requestData["region_master_last"];
m_app.CreateRegion(newRegionData);
Hashtable responseData = new Hashtable();
responseData["created"] = "true";
response.Value = responseData;
}
catch (Exception e)
{
Hashtable responseData = new Hashtable();
responseData["created"] = "false";
responseData["error"] = e.ToString();
response.Value = responseData;
}
return response;
}
}
}
using System;
using System.Collections.Generic;
using System.Collections;
using System.IO;
using System.Text;
using Nini.Config;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Console;
using OpenSim.Framework.Interfaces;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Types;
using OpenSim.Framework.Utilities;
using OpenSim.Region.ClientStack;
using OpenSim.Region.Communications.Local;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Physics.Manager;
using System.Globalization;
using Nwc.XmlRpc;
using RegionInfo = OpenSim.Framework.Types.RegionInfo;
namespace OpenSim
{
class OpenSimController
{
private OpenSimMain m_app;
private BaseHttpServer m_httpServer;
private const bool m_enablexmlrpc = false;
public OpenSimController(OpenSimMain core, BaseHttpServer httpd)
{
m_app = core;
m_httpServer = httpd;
if (m_enablexmlrpc)
{
m_httpServer.AddXmlRPCHandler("admin_create_region", XmlRpcCreateRegionMethod);
m_httpServer.AddXmlRPCHandler("admin_shutdown", XmlRpcShutdownMethod);
}
}
public XmlRpcResponse XmlRpcShutdownMethod(XmlRpcRequest request)
{
MainLog.Instance.Verbose("CONTROLLER", "Recieved Shutdown Administrator Request");
XmlRpcResponse response = new XmlRpcResponse();
Hashtable requestData = (Hashtable)request.Params[0];
if ((string)requestData["shutdown"] == "delayed")
{
int timeout = Convert.ToInt32((string)requestData["milliseconds"]);
Hashtable responseData = new Hashtable();
responseData["accepted"] = "true";
response.Value = responseData;
m_app.SceneManager.SendGeneralMessage("Region is going down in " + ((int)(timeout / 1000)).ToString() + " second(s). Please save what you are doing and log out.");
// Perform shutdown
System.Timers.Timer shutdownTimer = new System.Timers.Timer(timeout); // Wait before firing
shutdownTimer.AutoReset = false;
shutdownTimer.Elapsed += new System.Timers.ElapsedEventHandler(shutdownTimer_Elapsed);
return response;
}
else
{
Hashtable responseData = new Hashtable();
responseData["accepted"] = "true";
response.Value = responseData;
m_app.SceneManager.SendGeneralMessage("Region is going down now.");
// Perform shutdown
System.Timers.Timer shutdownTimer = new System.Timers.Timer(2000); // Wait 2 seconds before firing
shutdownTimer.AutoReset = false;
shutdownTimer.Elapsed += new System.Timers.ElapsedEventHandler(shutdownTimer_Elapsed);
return response;
}
}
void shutdownTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
m_app.Shutdown();
}
public XmlRpcResponse XmlRpcCreateRegionMethod(XmlRpcRequest request)
{
MainLog.Instance.Verbose("CONTROLLER", "Recieved Create Region Administrator Request");
XmlRpcResponse response = new XmlRpcResponse();
Hashtable requestData = (Hashtable)request.Params[0];
RegionInfo newRegionData = new RegionInfo();
try
{
newRegionData.RegionID = (string)requestData["region_id"];
newRegionData.RegionName = (string)requestData["region_name"];
newRegionData.RegionLocX = Convert.ToUInt32((string)requestData["region_x"]);
newRegionData.RegionLocY = Convert.ToUInt32((string)requestData["region_y"]);
// Security risk
newRegionData.DataStore = (string)requestData["datastore"];
newRegionData.InternalEndPoint = new System.Net.IPEndPoint(
System.Net.IPAddress.Parse((string)requestData["listen_ip"]), 0);
newRegionData.InternalEndPoint.Port = Convert.ToInt32((string)requestData["listen_port"]);
newRegionData.ExternalHostName = (string)requestData["external_address"];
newRegionData.MasterAvatarFirstName = (string)requestData["region_master_first"];
newRegionData.MasterAvatarLastName = (string)requestData["region_master_last"];
m_app.CreateRegion(newRegionData);
Hashtable responseData = new Hashtable();
responseData["created"] = "true";
response.Value = responseData;
}
catch (Exception e)
{
Hashtable responseData = new Hashtable();
responseData["created"] = "false";
responseData["error"] = e.ToString();
response.Value = responseData;
}
return response;
}
}
}