public async Task GetMyPodAsyncHitsTheUri()
        {
            var httpClientSettingsMock = GetKubeHttpClientSettingsProviderForTest();

            var httpClientMock = new Mock <IKubeHttpClient>();

            httpClientMock.Setup(httpClient => httpClient.Settings).Returns(httpClientSettingsMock.Object);
            // httpClientMock.Setup(httpClient => httpClient.GetStringAsync(It.IsAny<Uri>())).Returns(Task.FromResult(JsonConvert.SerializeObject(new K8sEntityList<K8sPod>())));

            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(JsonConvert.SerializeObject(new K8sEntityList <K8sPod>()))
            };

            httpClientMock.Setup(httpClient => httpClient.SendAsync(It.IsAny <HttpRequestMessage>())).Returns(Task.FromResult(
                                                                                                                  response));

            using (K8sQueryClient target = new K8sQueryClient(httpClientMock.Object))
            {
                await target.GetMyPodAsync();
            }

            httpClientMock.Verify(mock => mock.SendAsync(It.Is <HttpRequestMessage>(
                                                             m => m.RequestUri.AbsoluteUri.Equals("https://baseaddress/api/v1/namespaces/queryNamespace/pods"))), Times.Once);
        }
示例#2
0
        /// <summary>
        /// Wait until the container is ready.
        /// Refer document @ https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-phase for the Pod's lifecycle.
        /// </summary>
        /// <param name="timeout">Timeout on Application Insights data when the container is not ready after the period.</param>
        /// <param name="client">Query client to try getting info from the Kubernetes cluster API.</param>
        /// <param name="myContainerId">The container that we are interested in.</param>
        /// <returns></returns>
        private static async Task <bool> SpinWaitContainerReady(TimeSpan timeout, K8sQueryClient client, string myContainerId, ILogger <K8sEnvironment> logger)
        {
            DateTime  tiemoutAt = DateTime.Now.Add(timeout);
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            K8sPod myPod = null;

            do
            {
                // When my pod become available and it's status become ready, we recognize the container is ready.
                myPod = await client.GetMyPodAsync().ConfigureAwait(false);

                if (myPod != null && myPod.GetContainerStatus(myContainerId).Ready)
                {
                    stopwatch.Stop();
                    logger?.LogDebug(Invariant($"K8s info avaialbe in: {stopwatch.ElapsedMilliseconds} ms."));
                    return(true);
                }

                // The time to get the container ready dependes on how much time will a container to be initialized.
                // But the minimum seems about 1000ms. Try invoke a probe on readiness every 500ms until the container is ready
                // Or it will timeout per the timeout settings.
                await Task.Delay(500).ConfigureAwait(false);
            } while (DateTime.Now < tiemoutAt);
            return(false);
        }
示例#3
0
        /// <summary>
        /// Wait until the container is ready.
        /// Refer document @ https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-phase for the Pod's lifecycle.
        /// </summary>
        /// <param name="timeout">Timeout on Application Insights data when the container is not ready after the period.</param>
        /// <param name="client">Query client to try getting info from the Kubernetes cluster API.</param>
        /// <param name="myContainerId">The container that we are interested in.</param>
        /// <returns></returns>
        private async Task <bool> SpinWaitContainerReady(DateTime timeoutAt, K8sQueryClient client, string myContainerId)
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            K8sPod myPod = null;

            do
            {
                // When my pod become available and it's status become ready, we recognize the container is ready.
                try
                {
                    myPod = await client.GetMyPodAsync().ConfigureAwait(false);
                }
                catch
                {
                    myPod = null;
                }

                if (myPod != null && myPod.GetContainerStatus(myContainerId).Ready)
                {
                    stopwatch.Stop();
                    _logger.LogDebug(Invariant($"K8s info avaialbe in: {stopwatch.ElapsedMilliseconds} ms."));
                    return(true);
                }

                // The time to get the container ready dependes on how much time will a container to be initialized.
                // When there is readiness probe, the pod info will not be available until the initial delay of it is elapsed.
                // When there is no readiness probe, the minimum seems about 1000ms.
                // Try invoke a probe on readiness every 500ms until the container is ready
                // Or it will timeout per the timeout settings.
                await Task.Delay(500).ConfigureAwait(false);
            } while (DateTime.Now < timeoutAt);
            return(false);
        }
        /// <summary>
        /// Async factory method to build the instance of a K8sEnvironment.
        /// </summary>
        /// <returns></returns>
        public async Task <K8sEnvironment> CreateAsync(TimeSpan timeout)
        {
            K8sEnvironment           instance = null;
            ILogger <K8sEnvironment> logger   = null;

            try
            {
                using (IKubeHttpClient httpClient = _httpClientFactory.Create(_httpClientSettings))
                    using (K8sQueryClient queryClient = _k8sQueryClientFactory.Create(httpClient))
                    {
                        string containerId = _httpClientSettings.ContainerId;
                        if (await SpinWaitContainerReady(timeout, queryClient, containerId).ConfigureAwait(false))
                        {
                            instance = new K8sEnvironment()
                            {
                                ContainerID = containerId
                            };

                            K8sPod myPod = await queryClient.GetMyPodAsync().ConfigureAwait(false);

                            instance.myPod = myPod;
                            logger?.LogDebug(Invariant($"Getting container status of container-id: {containerId}"));
                            instance.myContainerStatus = myPod.GetContainerStatus(containerId);

                            IEnumerable <K8sReplicaSet> replicaSetList = await queryClient.GetReplicasAsync().ConfigureAwait(false);

                            instance.myReplicaSet = myPod.GetMyReplicaSet(replicaSetList);

                            if (instance.myReplicaSet != null)
                            {
                                IEnumerable <K8sDeployment> deploymentList = await queryClient.GetDeploymentsAsync().ConfigureAwait(false);

                                instance.myDeployment = instance.myReplicaSet.GetMyDeployment(deploymentList);
                            }

                            if (instance.myPod != null)
                            {
                                IEnumerable <K8sNode> nodeList = await queryClient.GetNodesAsync().ConfigureAwait(false);

                                string nodeName = instance.myPod.Spec.NodeName;
                                if (!string.IsNullOrEmpty(nodeName))
                                {
                                    instance.myNode = nodeList.FirstOrDefault(node => !string.IsNullOrEmpty(node.Metadata?.Name) && node.Metadata.Name.Equals(nodeName, StringComparison.OrdinalIgnoreCase));
                                }
                            }
                        }
                        else
                        {
                            logger?.LogError(Invariant($"Kubernetes info is not available within given time of {timeout.TotalMilliseconds} ms."));
                        }
                    }
                return(instance);
            }
            catch (Exception ex)
            {
                logger?.LogCritical(ex.ToString());
                return(null);
            }
        }
        public void CtorSetsKubeHttpClient()
        {
            var settingsMock = new Mock <IKubeHttpClientSettingsProvider>();

            settingsMock.Setup(p => p.CreateMessageHandler()).Returns(new HttpClientHandler());
            using (KubeHttpClient httpClient = new KubeHttpClient(settingsMock.Object))
                using (K8sQueryClient target = new K8sQueryClient(httpClient))
                {
                    Assert.Same(httpClient, target.KubeHttpClient);
                }
        }
        public async Task GetReplicasAsyncAsyncShouldReturnsMultipleReplicas()
        {
            var httpClientSettingsMock = GetKubeHttpClientSettingsProviderForTest();

            var httpClientMock = new Mock <IKubeHttpClient>();

            httpClientMock.Setup(httpClient => httpClient.Settings).Returns(httpClientSettingsMock.Object);

            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(JsonConvert.SerializeObject(new K8sEntityList <K8sReplicaSet>
                {
                    Items = new List <K8sReplicaSet>()
                    {
                        new K8sReplicaSet()
                        {
                            Metadata = new K8sReplicaSetMetadata()
                            {
                                Name = "R1"
                            }
                        },
                        new K8sReplicaSet()
                        {
                            Metadata = new K8sReplicaSetMetadata()
                            {
                                Name = "R2"
                            }
                        }
                    }
                }))
            };

            httpClientMock.Setup(httpClient => httpClient.SendAsync(It.IsAny <HttpRequestMessage>())).Returns(Task.FromResult(response));

            IEnumerable <K8sReplicaSet> result;

            using (K8sQueryClient target = new K8sQueryClient(httpClientMock.Object))
            {
                result = await target.GetReplicasAsync();
            }
            Assert.NotNull(result);
            Assert.Equal(2, result.Count());
            Assert.Contains(result, p => p.Metadata.Name.Equals("R1"));
            Assert.Contains(result, p => p.Metadata.Name.Equals("R2"));
        }
示例#7
0
        private async Task <K8sPod> SpinWaitUntilGetPod(DateTime timeoutAt, K8sQueryClient client)
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            K8sPod myPod = null;

            do
            {
                // When my pod become available and it's status become ready, we recognize the container is ready.
                try
                {
                    myPod = await client.GetMyPodAsync().ConfigureAwait(false);
                }
#pragma warning disable CA1031 // Do not catch general exception types
                catch (Exception ex)
                {
                    _logger.LogWarning($"Query exception while trying to get pod info: {ex.Message}");
                    _logger.LogDebug(ex.ToString());
                    myPod = null;
                }
#pragma warning restore CA1031 // Do not catch general exception types

                if (myPod != null)
                {
                    stopwatch.Stop();
                    _logger.LogDebug(Invariant($"K8s info avaialbe in: {stopwatch.ElapsedMilliseconds} ms."));
                    return(myPod);
                }

                // The time to get the container ready dependes on how much time will a container to be initialized.
                // When there is readiness probe, the pod info will not be available until the initial delay of it is elapsed.
                // When there is no readiness probe, the minimum seems about 1000ms.
                // Try invoke a probe on readiness every 500ms until the container is ready
                // Or it will timeout per the timeout settings.
                await Task.Delay(500).ConfigureAwait(false);
            } while (DateTime.Now < timeoutAt);
            return(null);
        }
示例#8
0
        /// <summary>
        /// Async factory method to build the instance of a K8sEnvironment.
        /// </summary>
        /// <returns></returns>
        public async Task <IK8sEnvironment> CreateAsync(DateTime timeoutAt)
        {
            K8sEnvironment instance = null;

            try
            {
                using (IKubeHttpClient httpClient = _httpClientFactory.Create(_httpClientSettings))
                    using (K8sQueryClient queryClient = _k8sQueryClientFactory.Create(httpClient))
                    {
                        // TODO: See if there's better way to fetch the container id
                        K8sPod myPod = await SpinWaitUntilGetPod(timeoutAt, queryClient).ConfigureAwait(false);

                        if (myPod != null)
                        {
                            string containerId = null;
                            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                            {
                                // For Windows, is there a way to fetch the current container id from within the container?
                                containerId = myPod.Status.ContainerStatuses.First().ContainerID;
                            }
                            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
                            {
                                // For Linux, container id could be fetched directly from cGroup.
                                containerId = _httpClientSettings.ContainerId;
                            }
                            // ~

                            if (await SpinWaitContainerReady(timeoutAt, queryClient, containerId).ConfigureAwait(false))
                            {
                                instance = new K8sEnvironment()
                                {
                                    ContainerID = containerId
                                };

                                instance.myPod = myPod;
                                _logger.LogDebug(Invariant($"Getting container status of container-id: {containerId}"));
                                instance.myContainerStatus = myPod.GetContainerStatus(containerId);

                                IEnumerable <K8sReplicaSet> replicaSetList = await queryClient.GetReplicasAsync().ConfigureAwait(false);

                                instance.myReplicaSet = myPod.GetMyReplicaSet(replicaSetList);

                                if (instance.myReplicaSet != null)
                                {
                                    IEnumerable <K8sDeployment> deploymentList = await queryClient.GetDeploymentsAsync().ConfigureAwait(false);

                                    instance.myDeployment = instance.myReplicaSet.GetMyDeployment(deploymentList);
                                }

                                if (instance.myPod != null)
                                {
                                    IEnumerable <K8sNode> nodeList = await queryClient.GetNodesAsync().ConfigureAwait(false);

                                    string nodeName = instance.myPod.Spec.NodeName;
                                    if (!string.IsNullOrEmpty(nodeName))
                                    {
                                        instance.myNode = nodeList.FirstOrDefault(node => !string.IsNullOrEmpty(node.Metadata?.Name) && node.Metadata.Name.Equals(nodeName, StringComparison.OrdinalIgnoreCase));
                                    }
                                }
                            }
                            else
                            {
                                _logger.LogError(Invariant($"Kubernetes info is not available before the timeout at {timeoutAt}."));
                            }
                        }
                        else
                        {
                            // MyPod is null, meaning query timed out.
                            _logger.LogCritical("Fail to fetch the pod information in time. Kubernetes info will not be available for the telemetry.");
                            return(null);
                        }
                    }
                return(instance);
            }
            catch (Exception ex)
            {
                _logger.LogCritical(ex.ToString());
                return(null);
            }
        }
        public async Task GetMyPodAsyncShouldGetCorrectPod()
        {
            var httpClientSettingsMock = GetKubeHttpClientSettingsProviderForTest();

            var httpClientMock = new Mock <IKubeHttpClient>();

            httpClientMock.Setup(httpClient => httpClient.Settings).Returns(httpClientSettingsMock.Object);

            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(JsonConvert.SerializeObject(new K8sEntityList <K8sPod>
                {
                    Items = new List <K8sPod>
                    {
                        new K8sPod()
                        {
                            Status = new K8sPodStatus()
                            {
                                ContainerStatuses = new List <ContainerStatus>()
                                {
                                    new ContainerStatus()
                                    {
                                        ContainerID = "noisy in front"
                                    }
                                }
                            }
                        },
                        new K8sPod()
                        {
                            Status = new K8sPodStatus()
                            {
                                ContainerStatuses = new List <ContainerStatus>()
                                {
                                    new ContainerStatus()
                                    {
                                        ContainerID = "containerId"
                                    }
                                }
                            }
                        },
                        new K8sPod()
                        {
                            Status = new K8sPodStatus()
                            {
                                ContainerStatuses = new List <ContainerStatus>()
                                {
                                    new ContainerStatus()
                                    {
                                        ContainerID = "noisy after"
                                    }
                                }
                            }
                        }
                    }
                }))
            };

            httpClientMock.Setup(httpClient => httpClient.SendAsync(It.IsAny <HttpRequestMessage>())).Returns(Task.FromResult(response));

            using (K8sQueryClient target = new K8sQueryClient(httpClientMock.Object))
            {
                K8sPod result = await target.GetMyPodAsync();

                Assert.NotNull(result);
                Assert.Single(result.Status.ContainerStatuses);
                Assert.Equal("containerId", result.Status.ContainerStatuses.First().ContainerID);
            }
        }