public void testLoadPost()
{
storage = new LiteDBStorage(_testDbFilename);
Assert.AreEqual(0, storage.TotalItems);
var queue = new PersistentBlockingQueue(storage, new PayloadToJsonString());
var endpoint = new SnowplowHttpCollectorEndpoint(host: _collectorHostUri, port: 8080, protocol: HttpProtocol.HTTP, method: HttpMethod.POST, byteLimitPost: 100000);
var emitter = new AsyncEmitter(endpoint: endpoint, queue: queue, sendLimit: 1000);
var clientSession = new ClientSession(_testClientSessionFilename);
Assert.IsFalse(tracker.Started);
tracker.Start(emitter: emitter, clientSession: clientSession, trackerNamespace: "testNamespace", appId: "testAppId", encodeBase64: false, synchronous: false);
Assert.IsTrue(tracker.Started);
for (int i = 0; i < 100; i++)
{
tracker.Track(new Structured()
.SetCategory("exampleCategory")
.SetAction("exampleAction")
.SetLabel("exampleLabel")
.SetProperty("exampleProperty")
.SetValue(17)
.Build()
);
}
tracker.Flush();
tracker.Stop();
Assert.IsFalse(tracker.Started);
}
public void SessionValues()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var events = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => events.AddRange(x));
using (TestHelper.CreateDataContext())
{
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.Start();
}
Assert.AreEqual(1, events.Count);
Assert.AreEqual(0, events[0].ElapsedTime.Ticks);
}
var expected = new[]
{
".NET Framework Version", "Amount Of Memory", "Application Bitness", "Application Name",
"Application Version", "Bloodhound Version", "Machine ID", "Machine Name", "Machine User Name",
"Number Of Processors", "Operating System Bitness", "Operating System Name", "Operating System Service Pack",
"Operating System Version", "Screen Resolution", "Storage Available Space", "Storage Total Space"
};
var actual = events[0].Values.Select(x => x.Name).OrderBy(x => x).ToArray();
TestHelper.AreEqual(expected, actual);
}
override public void RunTest()
{
Thread.Sleep(Intervals[0]);
for (var i = 1; i < Intervals.Length; i++)
{
if (Tracker != null)
{
Logger.LogTraffic("------>Sending No. " + i + " taking " + Intervals[i] + " ms to respond.");
if (Tracker.IsMeltedDown())
{
Thread.Sleep(20); // this is to represent the cost to perform default operation when request is skipped due to melt down
//Logger.LogTestEvent("Skipped due to melt, saved blocking time for " + Intervals[i] + "Milli Seconds."); ;
continue;
}
var watcher = Tracker.Start();
watcher?.SetRequestDetail("runnerId", RunnerID);
watcher?.SetRequestDetail("index", i);
watcher?.SetRequestDetail("StartTime", watcher.StartTime.ToString("hh:mm:ss.fff"));
Thread.Sleep(Intervals[i]);
Tracker.Finish(watcher);
}
else // so that we can pass a null tracker to compare performance
{
Thread.Sleep(Intervals[i]);
}
Logger.LogTraffic("Runner " + RunnerID + "'s request No. " + i + " received its response.");
}
Logger.LogTestEvent("Runner " + RunnerID + " finished its test.");
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings = Speedy.Extensions.GetSerializerSettings(true, false);
GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);
GlobalConfiguration.Configuration.EnsureInitialized();
Database.SetInitializer(new MigrateDatabaseToLatestVersion <ScribeSqlDatabase, Configuration>(true));
var appDataPath = HttpContext.Current.Server.MapPath("~/App_Data");
var client = new ScribeDataChannel(new ScribeDatabaseProvider(() => new ScribeSqlDatabase()));
var provider = new KeyValueRepositoryProvider <Event>(appDataPath);
Tracker = Tracker.Start(client, provider);
using (var datacontext = new ScribeSqlDatabase())
{
var siteSettings = SiteSettings.Load(datacontext);
IsConfigured = datacontext.Users.Any();
PrintCss = siteSettings.PrintCss ?? string.Empty;
ViewCss = siteSettings.ViewCss ?? string.Empty;
}
}
static void Main(string[] args)
{
var workItems = Enumerable.Range(1, 2001).ToList();
var tracker = new Tracker(workItems.Count);
tracker.Every(100.ItemsDone(), LogCount);
tracker.Every(25.PercentDone(), LogPercent);
tracker.Every(10.Seconds(), LogSeconds);
tracker.On(50.PercentDone(), prog => Console.WriteLine("hey we're half done!"));
tracker.OnComplete(LogDone);
tracker.Start();
foreach (var item in workItems)
{
tracker.ItemStarted();
try {
ProcessItem(item);
tracker.ItemSucceeded();
}
catch (Exception) {
tracker.ItemFailed();
}
}
Console.ReadLine();
}
public void Exception()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
using (var tracker = Tracker.Start(channel.Object, provider))
{
tracker.AddException(new Exception("Boom"));
}
Assert.IsTrue(actual.Wait(x => x.Count == 2));
Assert.AreEqual(2, actual.Count);
Assert.AreEqual("Session", actual[0].Name);
Assert.AreEqual("Exception", actual[1].Name);
Assert.AreEqual(0, actual[1].ElapsedTime.TotalMilliseconds);
var actualValues = actual[1].Values;
Assert.AreEqual(2, actualValues.Count);
}
public void StartWithElapsedTime()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
var elapsedTime = TimeSpan.FromTicks(5465421643);
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
using (TestHelper.CreateDataContext())
{
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.Start(elapsedTime);
}
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(elapsedTime, actual[0].ElapsedTime);
Assert.AreEqual(elapsedTime, actual[0].CompletedOn - actual[0].CreatedOn);
}
var applicationName = actual[0].Values.First(x => x.Name == "Application Name");
Assert.AreEqual("Bloodhound.IntegrationTests", applicationName.Value);
}
public void TimedEventWithTimedChild()
{
var channel = new WebDataChannel("http://localhost");
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
using (var context = TestHelper.CreateDataContext())
{
using (var tracker = Tracker.Start(channel, provider))
{
var timedEvent = tracker.StartEvent("TimedEvent");
var childTimedEvent = timedEvent.StartEvent("ChildEvent");
Thread.Sleep(250);
childTimedEvent.Complete();
Thread.Sleep(250);
timedEvent.Complete();
}
Assert.IsTrue(context.Wait(x => x.Events.Count() == 3, 5000));
var actual = context.Events.ToList();
Assert.AreEqual(3, actual.Count);
Assert.AreEqual("Session", actual[0].Name);
Assert.AreEqual("TimedEvent", actual[1].Name);
Assert.IsTrue(actual[1].ElapsedTime.TotalMilliseconds > 500);
Assert.IsTrue(actual[1].ElapsedTime.TotalMilliseconds < 550);
Assert.AreEqual("ChildEvent", actual[2].Name);
Assert.IsTrue(actual[2].ElapsedTime.TotalMilliseconds > 250);
Assert.IsTrue(actual[2].ElapsedTime.TotalMilliseconds < 300);
}
}
public void TimedEventCompleteShouldOnlyFireOnce()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var count = 0;
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(events => count += events.Count());
using (var tracker = Tracker.Start(channel.Object, provider))
{
var timedEvent = tracker.StartEvent("TimedEvent");
timedEvent.Complete();
// Change unique ID so the repository would create a new event.
// Should not be added because complete should only fire once.
timedEvent.UniqueId = Guid.NewGuid();
timedEvent.Complete();
timedEvent.UniqueId = Guid.NewGuid();
timedEvent.Complete();
}
// Should only be two events.
Assert.AreEqual(2, count);
}
static void Main(string[] args)
{
Torrent torrent = new Torrent(BenDecoder.Decode(args[0]));
Tracker trackerClient = new Tracker(torrent);
Console.WriteLine("Connecting to tracker at {0}", torrent.AnnounceUri);
object cv = new object();
trackerClient.Connected += delegate
{
Console.WriteLine("Connected to {0}", torrent.AnnounceUri);
};
trackerClient.Updated += delegate
{
if (trackerClient.LastResponse.IsSuccessful)
{
Console.WriteLine("{0} Seeders, {1} leechers", trackerClient.LastResponse.NumberOfSeeds, trackerClient.LastResponse.NumberOfLeechers);
ConnectToPeers(trackerClient.LastResponse.Peers, torrent);
}
else
{
QuitWithError(cv, trackerClient.LastResponse.FailureReason);
}
};
trackerClient.Error += delegate(object sender, Exception e)
{
QuitWithError(cv, e.Message);
};
trackerClient.Start();
lock (cv)
{
Monitor.Wait(cv);
}
}
public void EventProcessingDelay()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
var watch = Stopwatch.StartNew();
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.EventProcessingDelay = 250;
tracker.Start();
tracker.Wait(x => x.EventProcessorRunning);
actual.Wait(x => x.Count == 1);
Thread.Sleep(50);
tracker.AddEvent("Event");
actual.Wait(x => x.Count == 2);
}
watch.Stop();
Console.WriteLine(watch.Elapsed.TotalMilliseconds);
Assert.IsTrue(watch.Elapsed.TotalMilliseconds > 250);
Assert.IsTrue(watch.Elapsed.TotalMilliseconds < 1000);
actual.Wait(x => x.Count == 2);
Assert.AreEqual(2, actual.Count);
Assert.AreEqual("Session", actual[0].Name);
Assert.AreEqual("Event", actual[1].Name);
Assert.AreEqual(0, actual[1].ElapsedTime.TotalMilliseconds);
}
public void WithOldSessions()
{
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var channel = new Mock <IDataChannel>();
var actual = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
TestHelper.Directory.SafeCreate();
var session = TestHelper.CreateSession();
using (var repository = provider.OpenRepository(session.SessionId.ToString()))
{
repository.WriteAndSave(session);
}
using (Tracker.Start(channel.Object, provider))
{
Thread.Sleep(500);
}
Assert.AreEqual(2, actual.Count);
session.Id = actual[1].Id;
TestHelper.AreEqual(session, actual[1]);
}
public void CanStartTracker()
{
tracker.Start();
tracker.Stop();
Thread.Sleep(1100);
informationReader.AssertWasCalled(i => i.GetArrivalEvents());
}
public void WithOldSessionsWithConnectionIssues()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
TestHelper.Directory.SafeCreate();
var expected = new List <Event>();
var session = TestHelper.CreateSession();
using (var repository = provider.OpenRepository(session.SessionId.ToString()))
{
repository.WriteAndSave(session);
}
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(events =>
{
var list = events.ToList();
if (list.Any(x => x.UniqueId == session.SessionId))
{
throw new Exception("Unable to connect to the remote server");
}
expected.AddRange(list);
});
using (Tracker.Start(channel.Object, provider))
{
Thread.Sleep(1000);
}
Assert.AreEqual(1, expected.Count);
Assert.AreEqual(EventType.Session, expected[0].Type);
}
static void Main(string[] args)
{
Torrent torrent = new Torrent(BenDecoder.Decode(args[0]));
Tracker trackerClient = new Tracker(torrent);
Console.WriteLine("Connecting to tracker at {0}", torrent.AnnounceUri);
object cv = new object();
trackerClient.Connected += delegate
{
Console.WriteLine("Connected to {0}", torrent.AnnounceUri);
};
trackerClient.Updated += delegate
{
if(trackerClient.LastResponse.IsSuccessful)
{
Console.WriteLine("{0} Seeders, {1} leechers", trackerClient.LastResponse.NumberOfSeeds, trackerClient.LastResponse.NumberOfLeechers);
ConnectToPeers(trackerClient.LastResponse.Peers, torrent);
}
else
{
QuitWithError(cv, trackerClient.LastResponse.FailureReason);
}
};
trackerClient.Error += delegate(object sender, Exception e)
{
QuitWithError(cv, e.Message);
};
trackerClient.Start();
lock(cv)
{
Monitor.Wait(cv);
}
}
//private float tracking_timer = 2;
//private bool tracking = true;
//void ResetTrackingTimer()
//{
// tracking_timer = 2;
//}
void ResumeTracking()
{
//ResetTrackingTimer();
Tracker imageTracker = TrackerManager.Instance.GetTracker <ObjectTracker>();
imageTracker.Start();
}
private static void WriterOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var worker = (BackgroundWorker)sender;
var server = ConfigurationManager.AppSettings["Server"];
var client = new WebDataChannel(server);
var provider = new RepositoryProvider(Directory, TimeSpan.FromMinutes(1), 1000);
var random = new Random(Guid.NewGuid().GetHashCode());
var count = 0;
while (!worker.CancellationPending)
{
using (var tracker = new Tracker(client, provider))
{
worker.ReportProgress(1, $"Starting writer {count++} ...");
tracker.Start(new EventValue("Count", count));
decimal eventCount = random.Next(10, 1000);
for (var i = 1; i <= eventCount; i++)
{
var item = tracker.StartEvent($"Event{i}");
var itemDelay = random.Next(1, 100);
worker.ReportProgress((int)(i / eventCount * 100), $"{i} of {eventCount}");
item.Values.Add(new EventValue("Delay", itemDelay));
Thread.Sleep(itemDelay);
item.Complete();
}
}
}
}
public void StartWithElapsedTimeAndCustomValues()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
var elapsedTime = TimeSpan.FromTicks(413124564);
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
using (TestHelper.CreateDataContext())
{
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.Start(elapsedTime, new EventValue("Foo", "Bar"));
}
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(elapsedTime, actual[0].ElapsedTime);
Assert.AreEqual(18, actual[0].Values.Count);
var eventValue = actual[0].Values.FirstOrDefault(x => x.Name == "Foo");
Assert.IsNotNull(eventValue);
Assert.AreEqual("Foo", eventValue.Name);
Assert.AreEqual("Bar", eventValue.Value);
}
var applicationName = actual[0].Values.First(x => x.Name == "Application Name");
Assert.AreEqual("Bloodhound.IntegrationTests", applicationName.Value);
}
public void ClosingTrackerClosesSocket()
{
tracker = new Tracker(file, socket);
tracker.Start();
Assert.IsTrue(socket.Connected);
tracker.Close();
Assert.IsFalse(socket.Connected);
}
public void ClosingTrackerClosesSocket()
{
tracker = new Tracker(file, socket);
tracker.Start();
Assert.IsTrue(socket.Connected);
tracker.Close();
Assert.IsFalse(socket.Connected);
}
public void StartLocationTracker()
{
if (Tracker.IsRunning)
{
return;
}
Tracker.Start();
}
void Start()
{
tracker = new Tracker(address, port);
tracker.Start();
for (int i = 0; i < registerObjects.Length; i++)
{
Register(registerObjects[i].go, registerObjects[i].trackID);
}
}
public void testTracker()
{
var storage = new LiteDBStorage(_testDbFilename);
Assert.AreEqual(0, storage.TotalItems);
var queue = new PersistentBlockingQueue(storage, new PayloadToJsonString());
var getRequestMock = new MockGet();
var postRequestMock = new MockPost();
var endpoint = new SnowplowHttpCollectorEndpoint("snowplowanalytics.com",
postMethod: new SnowplowHttpCollectorEndpoint.PostDelegate(postRequestMock.HttpPost),
getMethod: new SnowplowHttpCollectorEndpoint.GetDelegate(getRequestMock.HttpGet));
Assert.IsFalse(tracker.Started);
tracker.Start(new AsyncEmitter(endpoint, queue, sendLimit: 1), trackerNamespace: "testNamespace", appId: "testAppId", encodeBase64: false);
Assert.IsTrue(tracker.Started);
Assert.IsTrue(ensureSubjectSet(tracker));
Assert.IsTrue(ensurePageViewsWorkGet(tracker, getRequestMock));
Assert.IsTrue(ensureStructEventsWorkGet(tracker, getRequestMock));
Assert.IsTrue(ensureEcommerceTransactionWorksGet(tracker, getRequestMock));
Assert.IsTrue(ensureUnstructEventGet(tracker, getRequestMock));
tracker.Stop();
Assert.IsFalse(tracker.Started);
// Restart with base64 on
tracker.Start(new AsyncEmitter(endpoint, queue, sendLimit: 1), trackerNamespace: "testNamespace", appId: "testAppId", encodeBase64: true);
Assert.IsTrue(tracker.Started);
Assert.IsTrue(ensureUnstructEventGet(tracker, getRequestMock, true));
Assert.IsTrue(ensureScreenViewWorksGet(tracker, getRequestMock, true));
Assert.IsTrue(ensureTimingWorksGet(tracker, getRequestMock, true));
Assert.IsTrue(ensureContextsWorkGet(tracker, getRequestMock, true));
Assert.IsTrue(ensureSettersWorkGet(tracker, getRequestMock));
tracker.Stop();
Assert.IsFalse(tracker.Started);
}
private void MainWindowOnLoaded(object sender, RoutedEventArgs e)
{
var server = ConfigurationManager.AppSettings["Server"];
var client = new WebDataChannel(server);
Directory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + @"\BloodHoundPerformance";
var provider = new RepositoryProvider(Directory, TimeSpan.FromMinutes(1), 1000);
_tracker = Tracker.Start(client, provider);
}
public async Task Execute()
{
using (LogContext.PushProperty("Worker", "TestAWorker"))
using (var tracker = Tracker.Start())
{
Log.Information(configuration["Example"]);
Log.Information(configuration["TestAWorker:SomeProperty"]);
Log.Information("Hello TestAWorker");
}
}
public void ReceiveResponse()
{
tracker = new Tracker(file, socket);
bool responseReceived = false;
tracker.Updated += delegate(object sender, EventArgs e)
{
responseReceived = true;
Assert.IsTrue(tracker.LastResponse.IsSuccessful);
};
tracker.Start();
Assert.IsTrue(responseReceived);
}
public void ReceiveResponse()
{
tracker = new Tracker(file, socket);
bool responseReceived = false;
tracker.Updated += delegate(object sender, EventArgs e)
{
responseReceived = true;
Assert.IsTrue(tracker.LastResponse.IsSuccessful);
};
tracker.Start();
Assert.IsTrue(responseReceived);
}
void ToggleTracking()
{
Tracker imageTracker = TrackerManager.Instance.GetTracker <ObjectTracker>();
imageTargetTracking = !imageTargetTracking;
if (imageTargetTracking)
{
imageTracker.Start();
}
else
{
imageTracker.Stop();
}
}
public void HandleError()
{
FakeErrorSocket fakeSocket = new FakeErrorSocket();
fakeSocket.ErrorOnConnect = true;
tracker = new Tracker(file, fakeSocket);
bool errorReceived = false;
tracker.Error += delegate(object sender, Exception se)
{
errorReceived = true;
Assert.IsNotNull(se);
};
tracker.Start();
Assert.IsTrue(errorReceived);
}
// TO DO:
// ADD Logging
// Not use While True
// Add Configs
// Add Comments
// Research on optimazing
static void Main(string[] args)
{
List <ApiInfo> apis = new List <ApiInfo>();
List <ExchangeCurrencyInfo> currency = new List <ExchangeCurrencyInfo>();
using (var context = new CryptoCurrencyTrackerContext())
{
apis = context.API.ToList();
currency = context.Currency.ToList();
}
Tracker tracker = new Tracker(apis, currency);
tracker.Start();
}
IPointerTracker IPointerHandler.TrackPointer(PointerPosition position)
{
IPointerTracker newTracker = null;
if(null == _tracker)
{
Tracker tracker = new Tracker(this, _synthesizer);
_tracker = tracker;
newTracker = tracker;
tracker.Start(position);
}
return newTracker;
}
public void SendStartedMessage()
{
tracker = new Tracker(file, socket);
bool connected = false;
tracker.Connected += delegate(object sender, EventArgs e)
{
connected = true;
};
ByteString expectedMessage = new ByteString("GET /announce?info_hash=%cdt%feF%cc%a3%a0%e6%dc_%f7%1c%bd%82%82ljZ%5d%3e&" +
"peer_id=12345678901234567890&port=6881&compact=1&uploaded=0&downloaded=0&left=3706908089&event=started HTTP/1.1\r\n\r\n");
tracker.Start();
Assert.IsTrue(socket.Connected);
Assert.IsTrue(connected);
Assert.AreEqual(expectedMessage, socket.lastMessage);
}
private static void Main(string[] args)
{
var localPath = @"C:\Users\bobby\AppData\Local\Temp\BobsToolbox";
var client = new WebDataChannel("http://localhost", 30000);
var provider = new RepositoryProvider(localPath, TimeSpan.FromDays(1), 30000);
using (var tracker = new Tracker(client, provider))
{
tracker.Log += (x, y) => System.Console.WriteLine(x);
tracker.Start();
System.Console.WriteLine("Press any key");
System.Console.ReadKey();
}
}
public void HandleError()
{
FakeErrorSocket fakeSocket = new FakeErrorSocket();
fakeSocket.ErrorOnConnect = true;
tracker = new Tracker(file, fakeSocket);
bool errorReceived = false;
tracker.Error += delegate(object sender, Exception se)
{
errorReceived = true;
Assert.IsNotNull(se);
};
tracker.Start();
Assert.IsTrue(errorReceived);
}
public void TryAttachTracker()
{
if (IsTracking)
{
return;
}
if (!Settings.Persistent.TrackServers)
{
return;
}
ActiveTracker = new Tracker();
ActiveTracker.MessageReceived += ActiveTrackerOnMessageReceived;
ActiveTracker.Start();
}
/// <summary>
/// 创建组件
/// </summary>
/// <param name="context">创建上下文</param>
/// <returns>返回所创建的组件</returns>
public virtual object Create(IComponentContext context)
{
Guard.NotNull(context, "context");
//1. 记录并跟踪组件创建的对象图
Tracker.Start(context);
object instance = null;
try
{
//2. 得到组件监听管理器
var componentListner = context.Kernel.ListenerManager as IComponentListener;
//3. 在组件创建前进行监听
if (componentListner != null)
{
componentListner.OnPreCreation(context);
}
//4. 具体的 Create instance
instance = InternalCreate(context);
context.Instance = instance;
if (componentListner != null)
{
//5. 在组件创建后进行监听（这里就是依赖注入的扩张点）
componentListner.OnPostCreation(context);
//6. 在组件创建后对组件初始化进行监听
componentListner.OnInitialization(context);
//7. 在组件初始化后进行监听
componentListner.OnPostInitialization(context);
}
context.Args = null;
context.NamedArgs = null;
}
catch
{
throw;
}
finally
{
Tracker.Stop();
}
return(instance);
}
private void ConnectToTracker()
{
if(tracker != null)
{
tracker.Close();
}
tracker = new Tracker(torrent);
tracker.Error += new Tracker.TrackerErrorHandler(tracker_Error);
trackerStatus.Text = "Connecting...";
tracker.Connected += delegate(object sender, EventArgs arg)
{
MethodInvoker invoker = new MethodInvoker(delegate ()
{
trackerStatus.Text = "Updating...";
});
Invoke(invoker);
};
tracker.Updated += delegate(object sender, EventArgs arg)
{
MethodInvoker invoker = new MethodInvoker(delegate()
{
if (tracker.LastResponse.IsSuccessful)
{
trackerStatus.Text = "OK";
swarmSize.Text = string.Format("Peers: {0} Seeds: {1}", tracker.LastResponse.NumberOfLeechers, tracker.LastResponse.NumberOfSeeds);
UpdatePeerList();
}
else
{
trackerStatus.Text = string.Format("Error: {0}", tracker.LastResponse.FailureReason);
}
});
Invoke(invoker);
};
tracker.Start();
}