public CreateNewJobCommand(int numberOfJobs = 1)
		{
			NumberOfJobs = numberOfJobs;

			HttpSender = new HttpSender();
			ManagerUriBuilder = new ManagerUriBuilder();
		}
		public void Execute(object parameter)
		{
			Task.Factory.StartNew(() =>
			{
				var httpSender = new HttpSender();

				var nodeName = IntegrationControllerApiHelper.StartNewNode(httpSender);
			});
		}
		public static async Task<string> StartNewNode(HttpSender httpSender)
		{
			var allNodesUri = CreateUri(IntegrationControllerRouteConstants.Nodes);

			var httpResponseMessage = httpSender.PostAsync(allNodesUri);

			httpResponseMessage.Wait();

			var res = httpResponseMessage.Result;

			var content = await res.Content.ReadAsStringAsync();

			return content;
		}
		public static async Task<string> ShutDownNode(HttpSender httpSender,
		                                              string nodeName)
		{
			var deleteUri = CreateUri(IntegrationControllerRouteConstants.NodeById.Replace("{id}", nodeName));

			var httpResponseMessage = httpSender.DeleteAsync(deleteUri);

			httpResponseMessage.Wait();

			var res = httpResponseMessage.Result;

			var content = await res.Content.ReadAsStringAsync();

			return content;
		}
		public virtual void TestFixtureSetUp()
		{
			HttpSender = new HttpSender();
			HttpRequestManager = new HttpRequestManager();

			AppDomain = AppDomain.CurrentDomain;

			ManagerDbConnectionString =
				ConfigurationManager.ConnectionStrings["ManagerConnectionString"].ConnectionString;

			var configurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
			XmlConfigurator.ConfigureAndWatch(new FileInfo(configurationFile));

			DatabaseHelper.ClearDatabase(ManagerDbConnectionString);

			CancellationTokenSource = new CancellationTokenSource();

			AppDomainTask = new AppDomainTask(BuildMode);

			Task = AppDomainTask.StartTask(numberOfManagers: NumberOfManagers,
			                               numberOfNodes: NumberOfNodes,
										   useLoadBalancerIfJustOneManager: UseLoadBalancerIfJustOneManager,
										   cancellationTokenSource: CancellationTokenSource);

			bool managerUp = HttpRequestManager.IsManagerUp();
			while (!managerUp)
			{
				managerUp = HttpRequestManager.IsManagerUp();
			}

			if (WaitToStartUp)
			{
				var sqlNotiferCancellationTokenSource = new CancellationTokenSource();
				var sqlNotifier = new SqlNotifier(ManagerDbConnectionString);

				var task = sqlNotifier.CreateNotifyWhenNodesAreUpTask(NumberOfNodes,
																	  sqlNotiferCancellationTokenSource);
				task.Start();

				sqlNotifier.NotifyWhenAllNodesAreUp.Wait(TimeSpan.FromMinutes(10));
				sqlNotifier.Dispose();
			}
		}
		public HttpRequestManager()
		{
			HttpSender = new HttpSender();
			MangerUriBuilder = new ManagerUriBuilder();
		}
		public void StartDurationTest()
		{
			CancellationTokenSourceDurationTest = new CancellationTokenSource();

			Task.Factory.StartNew(() =>
			{
				while (true)
				{
					var tasksToDispose = _tasks.Where(task => task.IsCompleted);

					foreach (var task in tasksToDispose)
					{
						task.Dispose();

						_tasks.Remove(task);
					}

					if (CancellationTokenSourceDurationTest.Token.IsCancellationRequested)
					{
						CancellationTokenSourceDurationTest.Token.ThrowIfCancellationRequested();
					}
				}

			}, CancellationTokenSourceDurationTest.Token);

			Task.Factory.StartNew(() =>
			{
				var mangerUriBuilder = new ManagerUriBuilder();
				var addToJobQueueUri = mangerUriBuilder.GetAddToJobQueueUri();

				var httpSender = new HttpSender();				
			
				Random random = new Random();

				for (int i = 0; i < NumberOfMessages; i++)
				{

					if (CancellationTokenSourceDurationTest.Token.IsCancellationRequested)
					{
						CancellationTokenSourceDurationTest.Token.ThrowIfCancellationRequested();
					}

					var i1 = i;
					
					var randomTimeSpan = random.Next(MessageDurationFrom, MessageDurationTo);

					_tasks.Add(new Task<HttpResponseMessage>(() =>
						{
							var testJobTimerParams =
							new TestJobParams("Test job name " + i1, 
													TimeSpan.FromSeconds(randomTimeSpan));

						var jobParamsToJson = 
							JsonConvert.SerializeObject(testJobTimerParams);

							var jobQueueItem = new JobQueueItem
							{
							Name = "Job Name " + i1,
								Serialized = jobParamsToJson,
								Type = "NodeTest.JobHandlers.TestJobParams",
								CreatedBy = "WPF Client"
							};

						return httpSender.PostAsync(addToJobQueueUri, 
													jobQueueItem).Result;

					}, CancellationTokenSourceDurationTest.Token));
				}

				var sendJobEveryDurationTimer=
					new SendJobEveryDurationTimer<HttpResponseMessage>(_tasks,
																	   TimeSpan.FromSeconds(5),
																	   ProgressAction);

				CheckManagerDbTimer.Start();
				sendJobEveryDurationTimer.SendTimer.Start();
			});
		}