"http://dbflute.org/meta/lastadi10.dtd">
<components namespace="fessCrawler">

	<component class="org.lastaflute.di.naming.StyledNamingConvention">
	</component>

	<!-- Container -->
	<component name="crawlerContainer"
		class="org.codelibs.fess.crawler.container.LastaCrawlerContainer">
	</component>

        prometheus.io/path: /stats/prometheus
        prometheus.io/port: "15020"
        prometheus.io/scrape: "true"
        proxy.istio.io/overrides: '{"containers":[{"name":"istio-proxy","resources":{}}]}'

  various sources must be consolidated and injected using the container.

  Currently, mojo configuration is done externally to the container, in the
  DefaultPluginManager in the maven-core API. In order to get from here to
  there, we need to do several things to add capability to the default
  configuration of plexus. This document will detail those changes.

Container Enhancements

* ExpressionEvaluator

		Windows: m.generateWindowsContainerResources(pod, container),
	}
}

// generateWindowsContainerResources generates windows container resources config for runtime
func (m *kubeGenericRuntimeManager) generateWindowsContainerResources(pod *v1.Pod, container *v1.Container) *runtimeapi.WindowsContainerResources {
	wcr := m.calculateWindowsResources(container.Resources.Limits.Cpu(), container.Resources.Limits.Memory())

	return wcr
}

		}, {
			title:             "valid container index",
			containers:        []v1.Container{{Name: "container-1"}, {Name: "container-2"}},
			statuses:          []v1.ContainerStatus{{Name: "container-1"}, {Name: "container-2"}},
			idx:               1,
			expectedContainer: v1.Container{Name: "container-2"},
			expectedOK:        true,
		},
	}

	for _, tc := range testCases {

			},
			{
				Type:   v1.PodScheduled,
				Status: v1.ConditionTrue,
			},
		},
		ContainerStatuses: []v1.ContainerStatus{
			{
				Name:  "container1",
				Ready: true,
			},
			{
				Name:  "container2",
				Ready: true,
			},
		},
		Message: "Message",
	}
}

func TestReplaceOrAppendPodCondition(t *testing.T) {
	cType := v1.PodConditionType("ExampleType")

				continue
			}

			podResources.Containers = append(podResources.Containers, p.getContainerResources(pod, &container))
		}
	}

	for _, container := range pod.Spec.Containers {
		podResources.Containers = append(podResources.Containers, p.getContainerResources(pod, &container))
	}

	response := &podresourcesv1.GetPodResourcesResponse{
		PodResources: podResources,
	}
	return response, nil
}

			[]string{},
		},
		{
			"regular containers",
			field.NewPath("spec"),
			&api.PodSpec{
				Containers: []api.Container{
					{Name: "c1"},
					{Name: "c2"},
				},
			},
			[]string{"spec.containers[0]", "spec.containers[1]"},
		},
		{
			"init containers",
			field.NewPath("spec"),
			&api.PodSpec{
				InitContainers: []api.Container{
					{Name: "i1"},
					{Name: "i2"},
				},
			},

			containers: &corev1.Pod{Spec: corev1.PodSpec{Containers: []corev1.Container{app, proxy}}},
			want:       &proxy,
		},
		{
			name:       "no-sidecar",
			containers: &corev1.Pod{Spec: corev1.PodSpec{Containers: []corev1.Container{app}}},
			want:       nil,
		},
		{
			name:       "init-sidecar",
			containers: &corev1.Pod{Spec: corev1.PodSpec{InitContainers: []corev1.Container{proxy}, Containers: []corev1.Container{app}}},

// within the given pod. Returns an error if the reference can't be constructed or the
// container doesn't actually belong to the pod.
func GenerateContainerRef(pod *v1.Pod, container *v1.Container) (*v1.ObjectReference, error) {
	fieldPath, err := fieldPath(pod, container)
	if err != nil {
		// TODO: figure out intelligent way to refer to containers that we implicitly