cloudfoundry-incubator/eirini

func (c *LRPToStatefulSet) Convert(statefulSetName string, lrp *api.LRP, privateRegistrySecret *corev1.Secret) (*appsv1.StatefulSet, error) {

envs := shared.MapToEnvVar(lrp.Env)

fieldEnvs := []corev1.EnvVar{

{

Name: eirini.EnvPodName,

func main() {

var opts options

_, err := flags.ParseArgs(&opts, os.Args)

cmdcommons.ExitfIfError(err, "Failed to parse args")

func (c *APIConverter) ConvertLRP(request cf.DesireLRPRequest) (api.LRP, error) {

env := map[string]string{

"LANG": "en_US.UTF-8",

}

logger lager.Logger,

secrets SecretsClient,

statefulSets StatefulSetClient,

pods PodClient,

pdbClient PodDisruptionBudgetClient,

logger lager.Logger,

podClient client.Client,

jobsClient JobsClient,

podUpdater PodsClient,

reporter Reporter,

func (r Reconciler) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {

logger := r.logger.Session("task-completion-reconciler", lager.Data{"namespace": request.Namespace, "pod-name": request.Name})

pod := &corev1.Pod{}

if err := r.runtimeClient.Get(ctx, request.NamespacedName, pod); err != nil {

func (d *Desirer) Desire(ctx context.Context, namespace string, lrp *api.LRP, opts ...shared.Option) error {

logger := d.logger.Session("desire", lager.Data{"guid": lrp.GUID, "version": lrp.Version, "namespace": namespace})

statefulSetName, err := utils.GetStatefulsetName(lrp)

if err != nil {

applicationServiceAccount string,

registrySecretName string,

allowAutomountServiceAccountToken bool,

allowRunImageAsRoot bool,

latestMigration int,

func GetPodState(pod corev1.Pod) string {

if len(pod.Status.ContainerStatuses) == 0 || pod.Status.Phase == corev1.PodUnknown {

return api.UnknownState

}

pod *v1.Pod,

reason string,

exitStatus int,

exitDescription string,

crashTimestamp int64,

func (g DefaultCrashEventGenerator) Generate(ctx context.Context, pod *v1.Pod, logger lager.Logger) (events.CrashEvent, bool) {

logger = logger.Session("generate-crash-event",

lager.Data{

"pod-name": pod.Name,

"guid": pod.Annotations[stset.AnnotationProcessGUID],

func (r *Reconciler) reportIfRequired(ctx context.Context, pod *corev1.Pod) error {

if pod.Annotations[jobs.AnnotationCCAckedTaskCompletion] == jobs.TaskCompletedTrue {

return nil

}

func (c *CrashReconciler) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {

logger := c.logger.Session("reconcile-pod-crash",

lager.Data{

"name": request.NamespacedName.Name,

"namespace": request.NamespacedName.Namespace,

logger lager.Logger,

statefulSetGetter StatefulSetByLRPIdentifierGetter,

podGetter PodGetter,

eventGetter EventGetter,

statefulsetToLrpConverter StatefulSetToLRPConverter,

func (e *Executor) migrateObjects(ctx context.Context, logger lager.Logger, objects []runtime.Object, objectType ObjectType, setAnnotationFn func(context.Context, runtime.Object, int) error) error {

func do(ctx context.Context, client *http.Client, method string, uri string, body interface{}) error {

logger lager.Logger,

secrets SecretsClient,

statefulSets StatefulSetCreator,

lrpToStatefulSetConverter LRPToStatefulSetConverter,

podDisruptionBudgetCreator PodDisruptionBudgetUpdater,

func (d *Desirer) Desire(ctx context.Context, namespace string, task *api.Task, opts ...shared.Option) error {

logger := d.logger.Session("desire-task", lager.Data{"guid": task.GUID, "name": task.Name, "namespace": namespace})

var (

err error

func do(ctx context.Context, client *http.Client, method string, uri string, body interface{}) error {

bodyJSON, err := json.Marshal(body)

if err != nil {

return errors.Wrap(err, "cannot marshal body")

}

func (g *Getter) GetInstances(ctx context.Context, identifier api.LRPIdentifier) ([]*api.Instance, error) {

logger := g.logger.Session("get-instance", lager.Data{"guid": identifier.GUID, "version": identifier.Version})

if _, err := g.getLRP(ctx, logger, identifier); errors.Is(err, eirini.ErrNotFound) {

return nil, err

}