public void New_TryDequeue_TryEnqueue_x50_TryDequeue_x50_TryDequeue_Count()
{
int value;
var q = new LockFreeQueue <int>();
Assert.AreEqual(0, q.Count);
q.TryDequeue(out value);
Assert.AreEqual(0, q.Count);
for (int i = 0; i < 50; ++i)
{
q.TryEnqueue(100 - i);
}
Assert.AreEqual(50, q.Count);
for (int i = 0; i < 50; ++i)
{
q.TryDequeue(out value);
Assert.AreEqual(100 - i, value);
}
Assert.AreEqual(0, q.Count);
q.TryDequeue(out value);
Assert.AreEqual(0, q.Count);
}
public static void Initialize(int toSendElements)
{
_internalQueue = new LockFreeQueue<CollectionElement>();
_collectedElements = 0;
_sentElements = 0;
_toSendElements = toSendElements;
}
public void LockFreeQueuePeek()
{
var queue = new LockFreeQueue <int>();
Int32 t = 0;
//We enqueue some items to test
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
//We check that after a peeking we have the correct value but the item
//is not deleted
Assert.IsTrue(queue.Peek(ref t));
Assert.AreEqual(t, 1);
Assert.AreEqual(queue.Count, 5);
queue.DequeueSingle();
Assert.IsTrue(queue.Peek(ref t));
Assert.AreEqual(t, 2);
Assert.AreEqual(queue.Count, 4);
queue.DequeueSingle();
Assert.IsTrue(queue.Peek(ref t));
Assert.AreEqual(t, 3);
Assert.AreEqual(queue.Count, 3);
queue.DequeueSingle();
Assert.IsTrue(queue.Peek(ref t));
Assert.AreEqual(t, 4);
Assert.AreEqual(queue.Count, 2);
queue.DequeueSingle();
Assert.IsTrue(queue.Peek(ref t));
Assert.AreEqual(t, 5);
Assert.AreEqual(queue.Count, 1);
queue.DequeueSingle();
Assert.IsFalse(queue.Peek(ref t));
}
public LuaScriptMgr()
{
Instance = this;
LuaStatic.Load = Loader;
lua = new LuaState();
_translator = lua.GetTranslator();
LuaDLL.luaopen_pb(lua.L);
//LuaDLL.luaopen_ffi(lua.L);
//OpenXml();
//OpenLuaCmd();
fileList = new HashSet <string>();
dict = new Dictionary <string, LuaBase>();
refGCList = new LockFreeQueue <int>(2048);
LuaDLL.lua_pushstring(lua.L, "ToLua_Index");
LuaDLL.luaL_dostring(lua.L, luaIndex);
LuaDLL.lua_rawset(lua.L, (int)LuaIndexes.LUA_REGISTRYINDEX);
LuaDLL.lua_pushstring(lua.L, "ToLua_NewIndex");
LuaDLL.luaL_dostring(lua.L, luaNewIndex);
LuaDLL.lua_rawset(lua.L, (int)LuaIndexes.LUA_REGISTRYINDEX);
LuaDLL.lua_pushstring(lua.L, "luaTableCall");
LuaDLL.luaL_dostring(lua.L, luaTableCall);
LuaDLL.lua_rawset(lua.L, (int)LuaIndexes.LUA_REGISTRYINDEX);
Bind();
#if MULTI_STATE
mgrList.Add(this);
#endif
//CmdTable.RegisterCommand("ToLua", ToLua.Generate);
//CmdTable.RegisterCommand("LuaGC", LuaGC);
}
/// <summary>
///Clear 的测试
///</summary>
public void ClearTestHelper <ValueT>()
{
LockFreeQueue <ValueT> target = new LockFreeQueue <ValueT>(); // TODO: 初始化为适当的值
target.Clear();
Assert.Inconclusive("无法验证不返回值的方法。");
}
public SelfRunningTaskPool(int interval, string name)
{
m_messageQueue = new LockFreeQueue <IMessage>();
m_queueTimer = Stopwatch.StartNew();
UpdateInterval = interval;
Name = name;
}
public MappedChart(string chartName, string xAxis, string yAxis, int length = 32, Color? primaryColor = null)
{
values = new double[length];
valueLength = length;
queuedPoints = new LockFreeQueue<DataPoint>();
CreateChart(chartName, xAxis, yAxis, primaryColor ?? Color.FromArgb(44, 139, 221), length);
}
protected SelfRunningTaskQueue(int updateInterval)
{
m_timers = new List <SimplerTimer>();
m_messageQueue = new LockFreeQueue <Action>();
m_queueTimer = Stopwatch.StartNew();
UpdateInterval = updateInterval;
}
public EventDispatcher(LockFreeQueue <Coroutines.EventMessage> events, CoroutineThread[] threads, CounterInt64 counter, Dictionary <string, Dictionary <Type, CoroutineEventDescriptor> > eventsList)
{
_events = events;
_threads = threads;
_counter = counter;
_eventsList = eventsList;
}
public EventManagerCoroutine(LockFreeQueue <CoroutineEventDescriptor> eventQueue, CounterInt64 counter,
Dictionary <string, Dictionary <Type, CoroutineEventDescriptor> > eventsDescriptors)
{
_eventsDescriptors = eventsDescriptors;
_eventDescriptorsQueue = eventQueue;
_counter = counter;
}
protected SelfRunningTaskQueue(int updateInterval)
{
m_timers = new List<SimplerTimer>();
m_messageQueue = new LockFreeQueue<Action>();
m_queueTimer = Stopwatch.StartNew();
UpdateInterval = updateInterval;
}
public void EnqueueTest_MutipleThread()
{
int seed = 0;
Thread[] threads = new Thread[this.m_threadCount];
LockFreeQueue <int> queue = new LockFreeQueue <int>();
for (int i = 0; i < this.m_threadCount; i++)
{
threads[i] = new Thread(() => {
for (int j = 0; j < this.m_dataCount; j++)
{
queue.Enqueue(Interlocked.Increment(ref seed));
}
});
}
for (int i = 0; i < this.m_threadCount; i++)
{
threads[i].Start();
}
for (int i = 0; i < this.m_threadCount; i++)
{
threads[i].Join();
}
Assert.AreEqual(this.m_threadCount * this.m_dataCount, queue.Count);
foreach (int item in queue)
{
Assert.AreNotEqual(0, item);
}
}
public MappedChart(string chartName, string xAxis, string yAxis, int length = 32, Color?primaryColor = null)
{
values = new double[length];
valueLength = length;
queuedPoints = new LockFreeQueue <DataPoint>();
CreateChart(chartName, xAxis, yAxis, primaryColor ?? Color.FromArgb(44, 139, 221), length);
}
public static void Initialize(int toSendElements)
{
_internalQueue = new LockFreeQueue <CollectionElement>();
_collectedElements = 0;
_sentElements = 0;
_toSendElements = toSendElements;
}
protected BaseMessageThread(ILogger logger, String threadName, bool restartOnError = true)
: base(logger, threadName, restartOnError)
{
_incomingMessages = new LockFreeQueue<IMessage>();
_outgoingMessages = new LockFreeQueue<IMessage>();
MaxMesssagesPerCycle = -1;
}
public string[] IterateFiles(string currentPath)
{
List <string> foundFiles = new List <string>();
LockFreeQueue <string> subPaths = new LockFreeQueue <string>();
do
{
try
{
string[] subDirectories = Directory.GetDirectories(currentPath);
for (int i = 0; i < subDirectories.Length; ++i)
{
subPaths.Push(subDirectories[i]);
}
string[] subFiles = Directory.GetFiles(currentPath);
foundFiles.AddRange(subFiles);
}
catch (Exception)
{
/// We don't care.
}
} while (subPaths.Pop(out currentPath));
return(foundFiles.ToArray());
}
/**
* @param port the port to listen on
* @param ipList an IEnumerable object of IPAddress objects.
* @param ta_auth the TAAuthorizer to use for remote nodes
*/
public TcpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth)
{
_is_started = 0;
_listen_sock = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
_listen_sock.LingerState = new LingerOption(true, 0);
IPEndPoint tmp_ep = new IPEndPoint(IPAddress.Any, port);
_listen_sock.Bind(tmp_ep);
_local_endpoint = (IPEndPoint)_listen_sock.LocalEndPoint;
port = _local_endpoint.Port;
_count = 0;
/**
* We get all the IPAddresses for this computer
*/
if (local_config_ips == null)
{
_tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Tcp, port);
}
else
{
_tas = TransportAddressFactory.Create(TransportAddress.TAType.Tcp, port, local_config_ips);
}
_ta_auth = ta_auth;
if (_ta_auth == null)
{
//Always authorize in this case:
_ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
}
_loop = new Thread(this.SelectLoop);
//This is how we push jobs into the SelectThread
ActionQueue = new LockFreeQueue <SocketStateAction>();
}
private void Awake()
{
pool = new MessagePool();
received = new LockFreeQueue <ReferenceCountedMessage>();
pc = GetComponentInParent <WebRtcPeerConnection>();
id = -1;
}
/// <summary>
///Enqueue 的测试
///</summary>
public void EnqueueTestHelper <ValueT>()
{
LockFreeQueue <ValueT> target = new LockFreeQueue <ValueT>(); // TODO: 初始化为适当的值
ValueT itemT = default(ValueT); // TODO: 初始化为适当的值
target.Enqueue(itemT);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public AsyncLog(string outputFile)
{
sb = new StringBuilder(1024);
filepath = outputFile;
lfq = new LockFreeQueue<Info>();
logThread = new Thread(new ThreadStart(RunLog));
logThread.Start();
}
public RoomPainter(TTClient parent)
{
client = parent;
paintingQueue = new LockFreeQueue<Action>();
chatLines = new string[0];
threadTicker = new Timer(Tick, null, 300, 300); /// 4 fps :D
Instance = this;
}
public BufferManager(int segmentCount, int segmentSize)
{
this.m_segmentCount = segmentCount;
this.m_segmentSize = segmentSize;
this.m_buffers = new List <ArrayBuffer>();
this.m_availableSegments = new LockFreeQueue <BufferSegment>();
BufferManager.Managers.Add(this);
}
public ClientHandler(ILog log)
{
cjdBuy = new Dictionary <long, Msg300192_011>();
cjdSell = new Dictionary <long, Msg300192_011>();
sddBuy = new Dictionary <long, Msg300192_011>();
sddSell = new Dictionary <long, Msg300192_011>();
tljdBuy = new Dictionary <long, Msg300192_011>();
tljdSell = new Dictionary <long, Msg300192_011>();
tljdList = new List <Msg300192_011>();
zl = new Dictionary <long, Msg300192_011>();
lockFreeQueue = new LockFreeQueue <IByteBuffer>();
// redis = new RedisHelper(9, "128.6.5.10:6379,allowadmin=true");//包含DBNub,port
redis = new RedisHelper(Convert.ToInt32(ConfigHelper.Configuration["redisDB"]), ConfigHelper.Configuration["redisConn"]); //包含DBNub,port
// redisAsync = new RedisHelper(Convert.ToInt32(ConfigHelper.Configuration["redisDBAsync"]), ConfigHelper.Configuration["redisConnAsync"]);//包含DBNub,port
//redis = new RedisHelper(0, "128.6.2.85:6380,password = 123456");//包含DBNub,port
this.log = log;
//short[] shorts = new short[10];
// Buffer.SetByte(shorts, 0, Encoding.UTF8.GetBytes("1"));
// Console.WriteLine(Buffer);
//IByteBuffer bf = this.initialMessage.Allocator.Buffer(100);
this.initialMessage = Unpooled.Buffer(100);
// byte[] messageBytes = Encoding.UTF8.GetBytes("Hello world");
// this.initialMessage.WriteBytes(messageBytes);
//4
this.initialMessage.WriteInt(msgType);
//4
this.initialMessage.WriteInt(92);
//20
this.initialMessage.WriteString(senderCompID, Encoding.UTF8);
this.initialMessage.SetWriterIndex(28);
//20
this.initialMessage.WriteString(targetCompID, Encoding.UTF8);
this.initialMessage.SetWriterIndex(48);
//4
this.initialMessage.WriteInt(heartBtInt);
// this.initialMessage.SetWriterIndex(52);
//16
this.initialMessage.WriteString(password, Encoding.UTF8);
this.initialMessage.SetWriterIndex(68);
//32
this.initialMessage.WriteString(defaultApplVerID, Encoding.UTF8);
this.initialMessage.SetWriterIndex(100);
this.initialMessage.WriteInt(GenerateCheckSum(this.initialMessage, 100));
Thread threadLevel2 = new Thread(new ThreadStart(QueueLevel2));
threadLevel2.Start();
Thread lockFreeCount = new Thread(new ThreadStart(GetlockFreeCount));
lockFreeCount.Start();
}
public void New_TryEnqueue_Count()
{
var q = new LockFreeQueue <int>();
Assert.AreEqual(0, q.Count);
q.TryEnqueue(42);
Assert.AreEqual(1, q.Count);
}
private void PrepareQueueData(LockFreeQueue <int> queue, int dataCount)
{
int seed = 0;
for (int j = 0; j < dataCount; j++)
{
queue.Enqueue(Interlocked.Increment(ref seed));
}
}
public void StartIteration(string path)
{
TerminateCurrentIteration();
FoundDataForTreeView = new LockFreeQueue <DirectoryElement>();
FoundDataForXml = new LockFreeQueue <DirectoryElement>();
IterateDirectoryThread.Start(path);
}
/// <summary>
/// Constructs a new <see cref="Default"></see> object
/// </summary>
/// <param name="segmentCount">The number of chunks tocreate per segment</param>
/// <param name="segmentSize">The size of a chunk in bytes</param>
public BufferManager(int segmentCount, int segmentSize)
{
m_segmentCount = segmentCount;
m_segmentSize = segmentSize;
m_buffers = new List <ArrayBuffer>();
m_availableSegments = new LockFreeQueue <BufferSegment>();
m_segmentsInUse = new ConcurrentDictionary <int, BufferSegment>();
Managers.Add(this);
}
public LimitedPriorityQueue(IPriorityConverter <P> converter)
{
this.converter = converter;
this.queueList = new LockFreeQueue <T> [converter.PriorityCount];
for (int i = 0; i < queueList.Length; i++)
{
queueList[i] = new LockFreeQueue <T>();
}
}
public void New_TryDequeue_Count()
{
int value;
var q = new LockFreeQueue<int>();
Assert.AreEqual(0, q.Count);
q.TryDequeue(out value);
Assert.AreEqual(0, q.Count);
}
static RequestObjectMessage()
{
_resetEvents = new LockFreeQueue<ManualResetEventSlim>();
int count = 100;
while (count >= 0)
{
_resetEvents.Enqueue(new ManualResetEventSlim(false));
count--;
}
}
/// <summary>
///CopyTo 的测试
///</summary>
public void CopyToTestHelper <ValueT>()
{
LockFreeQueue <ValueT> target = new LockFreeQueue <ValueT>(); // TODO: 初始化为适当的值
ValueT[] arrayT = null; // TODO: 初始化为适当的值
int iArrayIndex = 0; // TODO: 初始化为适当的值
target.CopyTo(arrayT, iArrayIndex);
Assert.Inconclusive("无法验证不返回值的方法。");
}
/// <summary>
///ToArrayAndClear 的测试
///</summary>
public void ToArrayAndClearTestHelper <ValueT>()
{
LockFreeQueue <ValueT> target = new LockFreeQueue <ValueT>(); // TODO: 初始化为适当的值
ValueT[] expected = null; // TODO: 初始化为适当的值
ValueT[] actual;
actual = target.ToArrayAndClear();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public SelfRunningTaskPool(int interval, string name)
{
this.m_messageQueue = new LockFreeQueue <IMessage>();
this.m_queueTimer = Stopwatch.StartNew();
this.m_simpleTimers = new List <SimpleTimerEntry>();
this.m_timers = new List <TimerEntry>();
this.UpdateInterval = interval;
this.Name = name;
this.Start();
}
public void New_TryDequeue_Count()
{
int value;
var q = new LockFreeQueue <int>();
Assert.AreEqual(0, q.Count);
q.TryDequeue(out value);
Assert.AreEqual(0, q.Count);
}
/// <summary>
///GetEnumerator 的测试
///</summary>
public void GetEnumeratorTestHelper <ValueT>()
{
LockFreeQueue <ValueT> target = new LockFreeQueue <ValueT>(); // TODO: 初始化为适当的值
IEnumerator <ValueT> expected = null; // TODO: 初始化为适当的值
IEnumerator <ValueT> actual;
actual = target.GetEnumerator();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
///Dequeue 的测试
///</summary>
public void DequeueTestHelper <ValueT>()
{
LockFreeQueue <ValueT> target = new LockFreeQueue <ValueT>(); // TODO: 初始化为适当的值
ValueT expected = default(ValueT); // TODO: 初始化为适当的值
ValueT actual;
actual = target.Dequeue();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void LockFreeQueueVsConcurrentQueue()
{
lq = new LockFreeQueue <int>();
cq = new ConcurrentQueue <int>();
lqDestination = new LockFreeQueue <int>();
cqDestination = new ConcurrentQueue <int>();
addLqDone = new ManualResetEvent(false);
addCqDone = new ManualResetEvent(false);
remLqDone = new ManualResetEvent(false);
remCqDone = new ManualResetEvent(false);
// Create a thread for each adding-process.
BackgroundWorker adderLq = new BackgroundWorker();
adderLq.DoWork += addLq_DoWork;
adderLq.RunWorkerCompleted += addLq_Completed;
BackgroundWorker adderCq = new BackgroundWorker();
adderCq.DoWork += addCq_DoWork;
adderCq.RunWorkerCompleted += addCq_Completed;
// Create a thread for each removal-process.
BackgroundWorker removerLq = new BackgroundWorker();
removerLq.DoWork += removeLq_DoWork;
removerLq.RunWorkerCompleted += removeLq_Completed;
BackgroundWorker removerCq = new BackgroundWorker();
removerCq.DoWork += removeCq_DoWork;
removerCq.RunWorkerCompleted += removeCq_Completed;
// Start the whole shebang.
start = DateTime.Now;
//adderLq.RunWorkerAsync();
adderCq.RunWorkerAsync();
//addLqDone.WaitOne();
addCqDone.WaitOne();
//removerLq.RunWorkerAsync();
removerCq.RunWorkerAsync();
// Wait for all tests to finish.
//addLqDone.WaitOne();
addCqDone.WaitOne();
//remLqDone.WaitOne();
remCqDone.WaitOne();
Assert.AreEqual(0, lq.Count);
Assert.AreEqual(NUMBER_OF_OPERATIONS, lqDestination.Count);
Assert.IsEmpty(cq);
Assert.AreEqual(NUMBER_OF_OPERATIONS, cqDestination.Count);
}
static EventThrower()
{
peakQueueLength = 0;
eventThread = new Thread(new ThreadStart(EventThread));
syncWorkItems = new LockFreeQueue< WorkItem>();
newWorkItem = new AutoResetEvent(false);
eventThread.IsBackground = true; // So it will not linger once a main thread is gone
eventThread.Name = "EventThrower";
eventThread.Start();
}
/**
* @param max_enqueues the maximum number of times Enqueue is allowed, after
* @param state some arbitrary object we might want later
* that it will throw InvalidOperationException and the queue will be closed
*/
public Channel(int max_enqueues, object state) {
if( max_enqueues == 0 ) {
//This doesn't make sense
throw new ArgumentOutOfRangeException("max_enqueues", max_enqueues, "cannot be zero");
}
State = state;
_closed = 0;
_queue = new LockFreeQueue<object>();
_max_enqueues = max_enqueues;
_enqueues = 0;
_count = 0;
_close_event = new FireOnceEvent();
}
/// <summary>
///
/// </summary>
/// <param name="updateInterval"></param>
public TaskProcessorBase(string name, int updateInterval = 10)
{
UpdateInterval = updateInterval;
Name = name;
m_running = false;
m_messageQueue = new LockFreeQueue<Action>();
m_updatableObjects = new List<Updatable>();
m_timerList = new List<UpdatableTimer>();
m_queueTimer = new Stopwatch();
Start();
}
public void ItShouldBePossibleToClearAQueueAndDequeueASingleItem()
{
var lfq = new LockFreeQueue<string>();
var lele = new List<string>();
for (int i = 0; i < ENQUEUED_DATA; i++)
{
lele.Add("TEST_" + i);
}
lfq.Enqueue(lele);
Assert.AreEqual("TEST_0", lfq.DequeueSingle());
lfq.Clear();
Assert.IsNull(lfq.DequeueSingle());
}
public void ItShouldBePossibleToEnqueuAndDequeuNonNullableElements()
{
var lfq = new LockFreeQueue<int>();
var lele = new List<int>();
for (int i = 0; i < ENQUEUED_DATA; i++)
{
lele.Add(i);
}
lfq.Enqueue(lele);
Assert.AreEqual(0, lfq.DequeueSingle());
lfq.Clear();
Assert.AreEqual(0,lfq.Count);
Assert.AreEqual(0,lfq.DequeueSingle());
}
public void DoTestMultiWithParAndReadingThread()
{
const int iterations = 10000;
var lfq = new LockFreeQueue<int>();
_sendCounter = new CounterContainer();
_firstTestCounter = new CounterContainer();
_errorTestCounter = new CounterContainer();
var ttr = new TestThreads(false, ThirdTestReader, 5);
ttr.RunParallel(iterations, lfq, true);
var tts = new TestThreads(false, ThirdTestSender, 5);
tts.RunParallel(iterations, lfq);
while (_firstTestCounter.Counter < (iterations-1) && _errorTestCounter.Counter == 0)
{
Thread.Sleep(10);
}
Assert.AreEqual(0, _errorTestCounter.Counter);
Assert.AreEqual(iterations, _sendCounter.Counter);
Assert.AreEqual(iterations-1, _firstTestCounter.Counter);
tts.Terminate();
ttr.Terminate();
}
public long RunParallel(int count, object param = null,bool infinite=false)
{
var sw = new Stopwatch();
CyclesCounter = new CounterContainer();
Exceptions = new LockFreeQueue<Exception>();
Results = new LockFreeQueue<object>();
if (count % _maxDegreeOfParallelism != 0) throw new Exception();
var steps = count / _maxDegreeOfParallelism;
_runningThreads = _maxDegreeOfParallelism;
_eventStart = new ManualResetEventSlim(false);
for (int i = 0; i < _maxDegreeOfParallelism; i++)
{
var from = steps * i;
var to = steps * (i + 1);
var thread = new Thread(RunTask);
thread.Start(new Tuple<int, int, object,bool>(from, to, param, infinite));
_threads.Add(thread);
}
sw.Start();
_eventStart.Set();
if (_waitForTermination)
{
while (CyclesCounter.Counter < count)
{
Thread.Sleep(100);
}
}
else
{
return 0;
}
sw.Stop();
return sw.ElapsedMilliseconds;
}
public void New_TryEnqueue_Count()
{
var q = new LockFreeQueue<int>();
Assert.AreEqual(0, q.Count);
q.TryEnqueue(42);
Assert.AreEqual(1, q.Count);
}
public LogAction(TimeSpan interval, LockFreeQueue<SocketStateAction> q) {
_last_debug = DateTime.UtcNow;
_debug_period = interval;
_q = q;
}
/**
* @param port the port to listen on
* @param ipList an IEnumerable object of IPAddress objects.
* @param ta_auth the TAAuthorizer to use for remote nodes
*/
public TcpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth)
{
_is_started = 0;
_listen_sock = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
_listen_sock.LingerState = new LingerOption (true, 0);
IPEndPoint tmp_ep = new IPEndPoint(IPAddress.Any, port);
_listen_sock.Bind(tmp_ep);
_local_endpoint = (IPEndPoint) _listen_sock.LocalEndPoint;
port = _local_endpoint.Port;
_count = 0;
/**
* We get all the IPAddresses for this computer
*/
if( local_config_ips == null ) {
_tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Tcp, port);
}
else {
_tas = TransportAddressFactory.Create(TransportAddress.TAType.Tcp, port, local_config_ips);
}
_ta_auth = ta_auth;
if( _ta_auth == null ) {
//Always authorize in this case:
_ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow);
}
_loop = new Thread( this.SelectLoop );
//This is how we push jobs into the SelectThread
ActionQueue = new LockFreeQueue<SocketStateAction>();
}
public void New_Count()
{
var q = new LockFreeQueue<int>();
Assert.AreEqual(0, q.Count);
}
public string[] IterateFiles(string currentPath)
{
List<string> foundFiles = new List<string>();
LockFreeQueue<string> subPaths = new LockFreeQueue<string>();
do
{
try
{
string[] subDirectories = Directory.GetDirectories(currentPath);
for (int i = 0; i < subDirectories.Length; ++i) subPaths.Push(subDirectories[i]);
string[] subFiles = Directory.GetFiles(currentPath);
foundFiles.AddRange(subFiles);
}
catch (Exception)
{
/// We don't care.
}
} while (subPaths.Pop(out currentPath));
return foundFiles.ToArray();
}
/// <summary>
/// Continues to get more information about recipients after all information about endpoints is loaded
/// </summary>
/// <param name="sender"></param>
/// <param name="recipientIdentities"></param>
/// <param name="loadedEndpoints"></param>
/// <param name="callback"></param>
private void GetRecipientInfos(
IUserOrGroup sender,
bool forceRefresh,
HashSet<string> recipientIdentities,
LockFreeQueue<Endpoints> loadedEndpoints,
ParticleEndpoint particleEndpoint,
Action<EndpointInfo> callback,
Action<IEnumerable<string>> errorCallback,
Action<Exception> exceptionCallback)
{
try
{
// All of the unique particle endpoints, with the recipients at each
Dictionary<string, List<string>> recipientsAtEndpoints = new Dictionary<string, List<string>>();
Dictionary<string, string> establishTrustEndpoints = new Dictionary<string, string>();
Dictionary<string, string> requestedEndpoints = new Dictionary<string, string>();
Endpoints particleEndpoints;
while (loadedEndpoints.Dequeue(out particleEndpoints))
{
string endpoint;
if (particleEndpoints.TryGetEndpoint(particleEndpoint, out endpoint))
{
List<string> users;
if (recipientsAtEndpoints.TryGetValue(particleEndpoints[ParticleEndpoint.ReceiveNotification], out users))
users.Add(particleEndpoints.OpenIdOrWebFinger);
else
{
users = new List<string>();
users.Add(particleEndpoints.OpenIdOrWebFinger);
recipientsAtEndpoints[particleEndpoints[ParticleEndpoint.ReceiveNotification]] = users;
establishTrustEndpoints[particleEndpoints[ParticleEndpoint.ReceiveNotification]] = particleEndpoints[ParticleEndpoint.EstablishTrust];
requestedEndpoints[particleEndpoints[ParticleEndpoint.ReceiveNotification]] = particleEndpoints[particleEndpoint];
}
}
}
if (!forceRefresh)
{
// Load for situations where trust is already established
// copy is to avoid locked the database
this.persistedUserManagerData.Read(userManagerData =>
{
var recipientUser = userManagerData.GetUser(sender.Id);
foreach (var recipientAndToken in recipientUser.receiveNotificationEndpointsBySenderToken.Where(
r => recipientsAtEndpoints.ContainsKey(r.Value)))
{
var receiveNotificationEndpoint = recipientAndToken.Value;
var senderToken = recipientAndToken.Key;
string endpoint;
if (requestedEndpoints.TryGetValue(receiveNotificationEndpoint, out endpoint))
{
var recipientInfo = new EndpointInfo()
{
RecipientIdentities = recipientsAtEndpoints[receiveNotificationEndpoint],
Endpoint = endpoint,
SenderToken = senderToken
};
recipientsAtEndpoints.Remove(receiveNotificationEndpoint);
callback(recipientInfo);
}
}
});
}
// For situations where trust isn't established, establish trust and then use the callback
foreach (KeyValuePair<string, List<string>> endpointAndRecipients in recipientsAtEndpoints)
GetRecipientInfos(
sender,
endpointAndRecipients.Key,
establishTrustEndpoints[endpointAndRecipients.Key],
endpointAndRecipients.Value,
requestedEndpoints[endpointAndRecipients.Key],
callback,
errorCallback);
}
catch (Exception e)
{
exceptionCallback(e);
}
}
public void New_TryEnqueue_x50_TryDequeue_x50_TryDequeue_Count()
{
int value;
var q = new LockFreeQueue<int>();
Assert.AreEqual(0, q.Count);
for(int i = 0; i < 50; ++i) {
q.TryEnqueue(100 - i);
}
Assert.AreEqual(50, q.Count);
for(int i = 0; i < 50; ++i) {
q.TryDequeue(out value);
Assert.AreEqual(100 - i, value);
}
Assert.AreEqual(0, q.Count);
q.TryDequeue(out value);
Assert.AreEqual(0, q.Count);
}
/// <summary>
///
/// </summary>
protected Updatable()
{
m_messagesQueue = new LockFreeQueue<Action>();
m_subUpdatableObjects = new List<Updatable>();
m_timerList = new List<UpdatableTimer>();
}
public CloseAction(TcpEdge e, LockFreeQueue<SocketStateAction> q) {
_e = e;
_queue = q;
}
/// <summary>
/// Downloads all objects from the server. Used in order to fill the cache.
/// This function should be used with XenServer up to version 6.0. For XenServer higher than 6.0, GetAllObjects() should be used instead.
/// </summary>
/// <param name="session">The session over which to download the objects. Must not be null.</param>
/// <param name="changes">The queue that the ObjectChanges will be put into. Must not be null.</param>
public static void DownloadObjects(Session session, LockFreeQueue<ObjectChange> changes)
{
List<ObjectChange> list = new List<ObjectChange>();
Download_Task(session, list);
Download_Pool(session, list);
Download_VM(session, list);
Download_VM_metrics(session, list);
Download_VM_guest_metrics(session, list);
Download_Host(session, list);
Download_Host_crashdump(session, list);
Download_Host_patch(session, list);
Download_Host_metrics(session, list);
Download_Host_cpu(session, list);
Download_Network(session, list);
Download_VIF(session, list);
Download_VIF_metrics(session, list);
Download_PIF(session, list);
Download_PIF_metrics(session, list);
Download_SM(session, list);
Download_SR(session, list);
Download_VDI(session, list);
Download_VBD(session, list);
Download_VBD_metrics(session, list);
Download_PBD(session, list);
Download_Crashdump(session, list);
Download_Console(session, list);
if (session.APIVersion >= API_Version.API_1_2)
{
// Download Miami-only objects
Download_Pool_patch(session, list);
Download_Bond(session, list);
Download_VLAN(session, list);
}
if (session.APIVersion >= API_Version.API_1_3)
{
// Download Orlando-only objects
Download_Blob(session, list);
Download_Message(session, list);
}
if (session.APIVersion >= API_Version.API_1_6)
{
// Download George-only objects
Download_Subject(session, list);
}
if (session.APIVersion >= API_Version.API_1_7)
{
// Download Midnight Ride-only objects
Download_Role(session, list);
}
if (session.APIVersion >= API_Version.API_1_8)
{
// Download Cowley-only objects
Download_VMPP(session, list);
Download_Tunnel(session, list);
}
if (session.APIVersion >= API_Version.API_1_9)
{
// Download Boston-only objects
Download_VM_appliance(session, list);
Download_DR_task(session, list);
Download_PCI(session, list);
Download_PGPU(session, list);
Download_GPU_group(session, list);
Download_VGPU(session, list);
}
foreach (ObjectChange o in list)
{
changes.Enqueue(o);
}
}
/// <summary>
/// Blocks until events are sent on the session, then processes any received events and adds them
/// to eventQueue. Will always add at least one event to eventQueue.
/// This function should be used with XenServer up to version 6.0. For XenServer higher than 6.0, GetEvents() should be used instead.
/// </summary>
/// <param name="session"></param>
/// <param name="eventQueue"></param>
/// <param name="cancelled"></param>
public static void GetNextEvents(Session session, LockFreeQueue<ObjectChange> eventQueue, HTTP.FuncBool cancelled)
{
Proxy_Event[] proxyEvents;
try
{
proxyEvents = Event.next(session);
}
catch (WebException e)
{
// Catch timeout, and turn it into an EventNextBlockedException so we can recognise it later (CA-33145)
if (e.Status == WebExceptionStatus.Timeout)
throw new EventNextBlockedException();
else
throw;
}
if (proxyEvents.Length == 0)
throw new IOException("Event.next() returned no events; the server is misbehaving.");
if (cancelled())
return;
//We want to do the marshalling on this bg thread so as not to block the gui thread
foreach (Proxy_Event proxyEvent in proxyEvents)
{
ObjectChange objectChange = ProcessEvent(proxyEvent);
if (objectChange != null)
eventQueue.Enqueue(objectChange);
}
}
static void Main(string[] args)
{
Console.Write(@"Test Lock-free ");
if (testObject == TestObject.Pool)
{
Console.WriteLine("Pool");
testPool = true;
}
else if (testObject == TestObject.FastPool)
{
Console.WriteLine("Fast Pool");
testPool = true;
}
else if (testObject == TestObject.StackQueue)
{
Console.WriteLine("Stack & Queue (Not Pool)");
testPool = false;
}
else
throw new NotImplementedException();
Console.WriteLine(@"ThreadPool Test Starting...");
Console.WriteLine(@" All threads: {0}", threads);
Console.WriteLine(@" Buffers per thread: {0}", actions);
Console.WriteLine(@" Buffer pool size: {0}", poolSize);
Console.WriteLine();
if (testPool)
{
if (testObject == TestObject.Pool)
pool = new LockFreePool<Item>(poolSize);
if (testObject == TestObject.FastPool)
pool = new LockFreeFastPool<Item>(poolSize);
}
else
{
array = new LockFreeItem<Item>[poolSize + 1];
for (int i = 1; i < array.Length; i++)
array[i].Value = new Item();
queue = new LockFreeQueue<Item>(array, 0, poolSize + 1);
stack = new LockFreeStack<Item>(array, -1, -1);
}
items = new bool[65536];
run = true;
for (int i = 0; i < threads; i++)
{
var thread = new Thread(TestBufferPool);
thread.Start();
}
Console.WriteLine(@"Started. Press any key to stop...");
Console.ReadKey(true);
run = false;
while (count > 0)
Thread.Sleep(25);
}
// TODO
// A lot of the logic in this file that's not tied to the DB should move someplace else so that independent implementations can use it
/// <summary>
/// Gets information about recipients for sending a notification
/// </summary>
/// <param name="openIdOrWebFinger"></param>
/// <param name="forceRefresh"></param>
/// <returns></returns>
public void GetEndpointInfos(
IUserOrGroup sender,
bool forceRefresh,
IEnumerable<string> recipientIdentitiesArg,
ParticleEndpoint particleEndpoint,
Action<EndpointInfo> callback,
Action<IEnumerable<string>> errorCallback,
Action<Exception> exceptionCallback)
{
HashSet<string> recipientIdentities = new HashSet<string>(recipientIdentitiesArg);
long outstandingRequests = recipientIdentities.Count;
LockFreeQueue<Endpoints> loadedEndpoints = new LockFreeQueue<Endpoints>();
Action<Endpoints> endpointLoaded = delegate(Endpoints endpoints)
{
loadedEndpoints.Enqueue(endpoints);
if (0 == Interlocked.Decrement(ref outstandingRequests))
GetRecipientInfos(sender, forceRefresh, recipientIdentities, loadedEndpoints, particleEndpoint, callback, errorCallback, exceptionCallback);
};
Action<Exception> endpointException = delegate(Exception e)
{
if (0 == Interlocked.Decrement(ref outstandingRequests))
GetRecipientInfos(sender, forceRefresh, recipientIdentities, loadedEndpoints, particleEndpoint, callback, errorCallback, exceptionCallback);
};
foreach (string openIdOrWebFinger in recipientIdentities)
Endpoints.GetEndpoints(openIdOrWebFinger, forceRefresh, endpointLoaded, endpointException);
}
/// <summary>
/// Blocks until events are sent on the session, or timeout is reached, then processes any received events and adds them
/// to eventQueue. This function implements the new event system, available in API version 1.9.
/// In the new event system, (GetAllRecords + GetEvents) sequence will replace (RegisterForEvents + DownloadObjects + GetNextEvents).
/// </summary>
/// <param name="session"></param>
/// <param name="eventQueue"></param>
/// <param name="cancelled"></param>
/// <param name="legacyEventSystem">True if legacy event system (event.next) should be used.</param>
/// <param name="token">A token used by event.from().
/// It should be the empty string when event.from is first called, which is the replacement of get_all_records.
/// </param>
public static void GetEvents(Session session, LockFreeQueue<ObjectChange> eventQueue, HTTP.FuncBool cancelled, bool legacyEventSystem, ref string token)
{
if (legacyEventSystem)
{
GetNextEvents(session, eventQueue, cancelled);
return;
}
Proxy_Event[] proxyEvents;
try
{
var classes = new [] { "*" }; // classes that we are interested in receiving events from
var eventResult = Event.from(session, classes, token, EVENT_FROM_TIMEOUT);
token = eventResult.token;
proxyEvents = eventResult.events;
}
catch (WebException e)
{
// Catch timeout, and turn it into an EventNextBlockedException so we can recognise it later (CA-33145)
if (e.Status == WebExceptionStatus.Timeout)
throw new EventNextBlockedException();
else
throw;
}
if (cancelled())
return;
//We want to do the marshalling on this bg thread so as not to block the gui thread
foreach (Proxy_Event proxyEvent in proxyEvents)
{
ObjectChange objectChange = ProcessEvent(proxyEvent);
if (objectChange != null)
eventQueue.Enqueue(objectChange);
}
}
static CachedPictureBox()
{
cachedImages = new Dictionary<string, Image>();
cacheQueue = new LockFreeQueue<CachedPictureBox>();
}
/// <sumary>
/// Gets all objects from the server. Used in order to fill the cache.
/// This function implements the new event system, available from in API version 1.9.
/// In the new event system, (GetAllRecords + GetEvents) sequence will replace (RegisterForEvents + DownloadObjects + GetNextEvents).
/// </summary>
/// <param name="session">The session over which to download the objects. Must not be null.</param>
/// <param name="changes">The queue that the ObjectChanges will be put into. Must not be null.</param>
/// <param name="cancelled">Used by GetEvents().</param>
/// <param name="legacyEventSystem">True if legacy event system (event.next) should to be used.</param>
/// <param name="token">Used by GetEvents().</param>
public static void GetAllObjects(Session session, LockFreeQueue<ObjectChange> changes, HTTP.FuncBool cancelled, bool legacyEventSystem, ref string token)
{
if (legacyEventSystem)
{
DownloadObjects(session, changes);
return;
}
// download objects that are not covered by event.from(), e.g. Roles
List<ObjectChange> list = new List<ObjectChange>();
Download_Role(session, list);
foreach (ObjectChange o in list)
changes.Enqueue(o);
// get all objects with event.from()
token = "";
GetEvents(session, changes, cancelled, false, ref token);
}