public void GetInstance()
        {
            // Arrange
            const string instanceId = "eight";
            var request = new DescribeInstancesRequest { InstanceIds = new List<string> { instanceId } };
            var response = new DescribeInstancesResponse
            {
                Reservations = new List<Reservation>
                {
                    new Reservation
                    {
                        Instances = new List<Instance>
                        {
                            GenerateInstance(instanceId, InstanceStateName.Running)
                        }
                    }
                }
            };
            Ec2ClientMock.Setup(x => x.DescribeInstances(It.Is<DescribeInstancesRequest>(
                req => req.InstanceIds.First() == request.InstanceIds.First()
            ))).Returns(response);

            // Act
            Instance instance = InstanceService.GetInstance(instanceId);

            // Assert
            instance.State.Name.Should().Be(InstanceStateName.Running);
        }

        public void Run()
        {
            var instanceRequest = new DescribeInstancesRequest
            {
                InstanceIds = new List<string>()
                {
                    instance.InstanceId
                }
            };

            var limit = 600;

            DescribeInstancesResponse response = null;

            while (limit > 0)
            {
                response = awsClient.Ec2Client.DescribeInstances(instanceRequest);

                if (response.Reservations[0].Instances[0].State.Code == 16)
                    break;

                limit --;

                Thread.Sleep(1000);
            }

            if (response != null && response.Reservations[0].Instances[0].State.Code == 16)
                FinishedSuccessfully = true;
            else
            {
                Error = string.Format("Instance not launched yet. Last state: {0}.", response.Reservations[0].Instances[0].State.Name);
            }
        }

        public RegionDetails GetRegionData(AwsRegionLocations region)
        {
            var regionEndpoint = region.ToAwsRegionEndpoint();

            // Get an Ec2Client for the current region
            var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, regionEndpoint));

            // Get instances within the region
            // Start by creating the request
            var request = new DescribeInstancesRequest();

            // Add a filter to the request so that it only returns instances that are either in "Running" or "Pending" state.
            request.Filters.Add(new Filter("instance-state-code", new List<string>()
            {
                ((ushort)InstanceStatuses.Running).ToString(),
                ((ushort)InstanceStatuses.Pending).ToString()
            }));

            // Send the request to Amazon
            var reservations = client.DescribeInstances(request).Reservations;

            return new RegionDetails()
            {
                Name = regionEndpoint.SystemName,
                Region = region,
                Instances = reservations.SelectMany(x => x.Instances).Select(x => x.ToInstanceInfo()).ToList()
            };
        }

 public IEnumerable<Instance> GetInstances(IEnumerable<string> instanceIds)
 {
     var instancesRequest = new DescribeInstancesRequest();
     instancesRequest.InstanceIds.AddRange(instanceIds);
     var instances = _client.DescribeInstances(instancesRequest);
     return instances.Reservations.SelectMany(x => x.Instances);
 }

 public List<Reservation> ListInstancesByTag(string tagKey, string tagValue)
 {
     var describeInstancesRequest = new DescribeInstancesRequest()
     {
         Filter = new List<Filter>
                     {
                         new Filter()
                             {
                                 Name = "tag:" + tagKey,
                                 Value = new List<string>
                                     {
                                         tagValue
                                     },
                             },
                         new Filter()
                             {
                                 Name = "instance-state-name",
                                 Value = new List<string>
                                     {
                                         "running"
                                     },
                             }
                     }
     };
     try
     {
         var describeInstancesResponse = amazonEc2.DescribeInstances(describeInstancesRequest);
         return describeInstancesResponse.DescribeInstancesResult.Reservation;
     }
     catch (Exception ex)
     {
         logger.Log("AWS ERROR: " + ex.Message);
         throw new Exception("Cannot list instances");
     }
 }

        public IEnumerable<string> GetAllocatedIpAddresses()
        {
            var request = new DescribeInstancesRequest();
            var response = _ec2Client.DescribeInstances(request);

            return response.Reservations
                .SelectMany(x => x.Instances.Select(y => y.PrivateIpAddress))
                .Where(x => x != null);
        }

		public static List<Reservation> getReservationsInRegion(this API_AmazonEC2 amazonEC2, string region)
		{
		        "Gettting Reservations in region: {0}".info(region);
				var ec2ClientInRegion = amazonEC2.getEC2Client(region);
				var describesInstance = new DescribeInstancesRequest(); 				
				var reservations = ec2ClientInRegion.DescribeInstances(describesInstance)
													.DescribeInstancesResult
													.Reservation; 				
				return reservations;									  
		}

        public override void Execute()
        {
            AmazonEC2Client client = new AmazonEC2Client(AWSAuthConnection.OUR_ACCESS_KEY_ID, AWSAuthConnection.OUR_SECRET_ACCESS_KEY);
            DescribeInstancesRequest request = new DescribeInstancesRequest();
            DescribeInstancesResponse response = client.DescribeInstances(request);

            Dictionary<string, List<RunningInstance>> instances = new Dictionary<string, List<RunningInstance>>();
            foreach (Reservation r in response.DescribeInstancesResult.Reservation)
                foreach (RunningInstance i in r.RunningInstance)
                {
                    if (!instances.ContainsKey(i.ImageId))
                        instances[i.ImageId] = new List<RunningInstance>();

                    instances[i.ImageId].Add(i);
                }

            List<string> allImageIds = new List<string>();
            foreach (string imageId in instances.Keys)
                allImageIds.Add(imageId);

            DescribeImagesRequest imageReq = new DescribeImagesRequest();
            imageReq.ImageId = allImageIds;
            DescribeImagesResponse imageResp = client.DescribeImages(imageReq);

            Dictionary<string, Image> imageDescriptions = new Dictionary<string, Image>();
            foreach (Image image in imageResp.DescribeImagesResult.Image)
                imageDescriptions.Add(image.ImageId, image);

            foreach (string imageId in instances.Keys)
            {
                if (imageDescriptions.ContainsKey(imageId))
                    Console.WriteLine("--- {0} {1} ({2} {3})",
                        imageId,
                        imageDescriptions[imageId].ImageLocation,
                        imageDescriptions[imageId].Platform,
                        imageDescriptions[imageId].Architecture);
                else
                    Console.WriteLine("--- {0} (AMI not found)", imageId);

                foreach (RunningInstance i in instances[imageId])
                {
                    DateTime launchTime = DateTime.Parse(i.LaunchTime);
                    Console.Write("{0}\t{1}\t{2}\t{3}\t{4}", launchTime, i.InstanceType, i.InstanceState.Name, i.InstanceId, i.StateTransitionReason);
                    if (ips)
                        Console.Write("\t{0}\t{1}", i.PublicDnsName, i.PrivateDnsName);
                    Console.WriteLine();
                }

                Console.WriteLine();
            }
        }

        static void GetInstances(AWSCredentials credentials)
        {
            IAmazonEC2 client = AWSClientFactory.CreateAmazonEC2Client(credentials, RegionEndpoint.USEast1);

            DescribeInstancesRequest request = new DescribeInstancesRequest();
            request.Filters.Add(new Filter("instance-state-code", new List<string>() { "0", "16" }));

            DescribeInstancesResponse describeInstancesResponse = client.DescribeInstances();
            List<Reservation> reservations = describeInstancesResponse.Reservations;

            foreach (Instance instance in reservations.SelectMany(x => x.Instances))
            {
                Console.WriteLine("Instance with ID {0} is currently {1}", instance.InstanceId, instance.State.Name);
            }
        }

 public IEnumerable<Instance> GetInstances()
 {
     AmazonEC2Client client = _GetClient();
     var describeInstancesRequest = new DescribeInstancesRequest();
     var response = client.DescribeInstances(describeInstancesRequest);
     var instances = response.DescribeInstancesResult.Reservation.SelectMany(x => x.RunningInstance).Select(x => new{ x.InstanceId, State = x.InstanceState.Name, x.IpAddress, x.InstanceType, x.PublicDnsName, InstanceName = x.Tag.Where(y => y.Key == "Name").Select(z => z.Value).First(), });
     return instances.Select(instance => new Instance
                                             {
                                                 Name = instance.InstanceName,
                                                 State = instance.State,
                                                 Dns = instance.PublicDnsName,
                                                 Id = instance.InstanceId,
                                                 Ip = instance.IpAddress
                                             });
 }

 public IEnumerable<Instance> GetInstances()
 {
     var client = _GetClient();
     var describeInstancesRequest = new DescribeInstancesRequest();
     var response = client.DescribeInstances(describeInstancesRequest);
     return response.DescribeInstancesResult.Reservation
         .SelectMany(x => x.RunningInstance)
         .Select(x =>
                 new Instance
                 {
                     Id = x.InstanceId,
                     Name = x.Tag.Where(y => y.Key == "Name").Select(y => y.Value).First(),
                     State = x.InstanceState.Name,
                     Dns = x.PublicDnsName,
                     Ip = x.IpAddress,
                 });
 }

        /// <summary>
        /// Connect to an Amazon subscription and obtain information about instance reservations.
        /// </summary>
        protected override void AmazonExecute()
        {
            var request = new DescribeInstancesRequest
            {
                InstanceId = this.InstanceIds.Get(this.ActivityContext)
            };

            try
            {
                var response = EC2Client.DescribeInstances(request);
                this.Reservations.Set(this.ActivityContext, response.DescribeInstancesResult.Reservation);
            }
            catch (EndpointNotFoundException ex)
            {
                this.LogBuildMessage(ex.Message);
            }
        }

        public List<Instance> GetInstances()
        {
            var instances = new List<Instance>();

            var ec2Request = new DescribeInstancesRequest();

            var ec2Response = _client.DescribeInstances(ec2Request);
            foreach (var reservation in ec2Response.Reservations)
            {
                var instance = reservation.Instances.Single();
                instances.Add(instance);
                //var name = instance.Tags.Single(x => x.Key == "Name").Value;
                //sr.WriteLine("{0} {1} {2} {3}", i++, name, instance.State.Name, instance.PublicDnsName);
            }

            return instances;
        }

        protected override void ProcessRecord()
        {
            AmazonEC2 client = base.GetClient();
            Amazon.EC2.Model.DescribeInstancesRequest request = new Amazon.EC2.Model.DescribeInstancesRequest();
            if (!string.IsNullOrEmpty(this._InstanceId))
            {
                request.InstanceId.Add(this._InstanceId);
            }
            Amazon.EC2.Model.DescribeInstancesResponse response = client.DescribeInstances(request);

            foreach(Reservation reservation in response.DescribeInstancesResult.Reservation)
            {
                base.WriteObject(reservation.RunningInstance);
            }

            
        }

        public List<RunningInstance> InstanceDescriptions(IEnumerable<string> instanceIds)
        {
            try
            {
                var request = new DescribeInstancesRequest().WithInstanceId(instanceIds.ToArray());
                var response = this.client.DescribeInstances(request);

                return response
                    .DescribeInstancesResult
                    .Reservation
                    .SelectMany(reservation => reservation.RunningInstance)
                    .ToList();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception occurred getting instance states: ");
                Console.WriteLine(ex.Message);
                return new List<RunningInstance>();
            }
        }

        public static IList<Ec2Record> GetAllEc2Instances(bool force = false)
        {
            if (m_Ec2Records == null || force)
            {
                var ec2 = Ec2ConnectionProvider.GetEc2Connection();

                DescribeInstancesRequest request = new DescribeInstancesRequest();
                DescribeInstancesResponse res = ec2.DescribeInstances(request);

                m_Ec2Records = new List<Ec2Record>();

                res.DescribeInstancesResult.Reservations.ForEach(
                    reservation => reservation.Instances.ForEach(
                        runningInstance => m_Ec2Records.Add(
                            new Ec2Record()
                                {
                                    InstanceId = runningInstance.InstanceId,
                                    Status = runningInstance.State.Name,
                                    Type = runningInstance.InstanceType,
                                    Platform = string.IsNullOrWhiteSpace(runningInstance.Platform) ? "Linux" : "Windows",
                                    Ip = string.IsNullOrEmpty(runningInstance.PublicIpAddress) ? "-" : runningInstance.PublicIpAddress,
                                    PrivateIp = runningInstance.PrivateIpAddress,
                                    PublicDns = runningInstance.PublicDnsName,
                                    PrivateDns = string.IsNullOrEmpty(runningInstance.PrivateDnsName) ? "-" : runningInstance.PrivateDnsName,
                                    Name = AwsTags.GetValueFromEc2Tag(runningInstance.Tags, "Name"),
                                    AttachedVolumes = VolumeProvider.GetVolumesByEc2Id(runningInstance.InstanceId),
                                    LaunchTime = runningInstance.LaunchTime,
                                    SecurityGroups = runningInstance
                                                        .SecurityGroups
                                                        .Select(group => group.GroupName)
                                                        .ToList()
                                }
                                               )
                                       )
                    );
            }

            return m_Ec2Records;
        }

        public static void InvokeListInstances()
        {
            NameValueCollection appConfig = ConfigurationManager.AppSettings;

            AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(
                appConfig["AWSAccessKey"],
                appConfig["AWSSecretKey"],
                RegionEndpoint.USWest2
                );

            DescribeInstancesRequest request = new DescribeInstancesRequest();

            try
            {
                DescribeInstancesResponse ec2Response = ec2.DescribeInstances(request);
                int numInstances = 0;
                numInstances = ec2Response.DescribeInstancesResult.Reservation.Count;
                Console.WriteLine("You have " + numInstances + " Amazon EC2 instance(s) running.");
            }
            catch (AmazonEC2Exception ex)
            {
                if (ex.ErrorCode.Equals("OptInRequired"))
                {
                    Console.WriteLine("You are not signed for Amazon EC2.");
                    Console.WriteLine("You can sign up at http://aws.amazon.com/ec2.");
                }
                else
                {
                    Console.WriteLine("Caught Exception: " + ex.Message);
                    Console.WriteLine("Response Status Code: " + ex.StatusCode);
                    Console.WriteLine("Error Code: " + ex.ErrorCode);
                    Console.WriteLine("Error Type: " + ex.ErrorType);
                    Console.WriteLine("Request ID: " + ex.RequestId);
                }
            }
            Console.WriteLine();
        }

        public DescribeInstancesResult GetInstances(Ec2Key ec2Key)
        {
            _logger.Debug("GetInstances Start.");

            AmazonEC2 ec2 = CreateAmazonEc2Client(ec2Key);

            var ec2Request = new DescribeInstancesRequest();

            DescribeInstancesResponse describeInstancesResponse = ec2.DescribeInstances(ec2Request);

            DescribeInstancesResult result = describeInstancesResponse.DescribeInstancesResult;

            _logger.Debug("GetInstances End.");

            return result;
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstances
        ///         operation.</returns>
        public IAsyncResult BeginDescribeInstances(DescribeInstancesRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DescribeInstancesRequestMarshaller();
            var unmarshaller = DescribeInstancesResponseUnmarshaller.Instance;

            return BeginInvoke<DescribeInstancesRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

 IAsyncResult invokeDescribeInstances(DescribeInstancesRequest describeInstancesRequest, AsyncCallback callback, object state, bool synchronized)
 {
     IRequest irequest = new DescribeInstancesRequestMarshaller().Marshall(describeInstancesRequest);
     var unmarshaller = DescribeInstancesResponseUnmarshaller.GetInstance();
     AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
     Invoke(result);
     return result;
 }