def job_restart_on_oomkilled_community(event: JobEvent, params: IncreaseResources):
    """
    This action will run when job failed with oomkilled
    """
    function_name = "JobRestartOnOomkilledCommunity"
    finding = Finding(
        title=f"JOB RESTARTED",
        source=FindingSource.MANUAL,
        aggregation_key=function_name,
        finding_type=FindingType.REPORT,
        failure=False,
    )
    if not event.get_job():
        logging.error(f"job restart was called on event without job: {event}")
        return
    job_event = event.get_job()

    """
    Retrieves job's pod information
    """
    try:
        pod = get_job_latest_pod(job_event)

    except:
        logging.error(f"get_job_pod was called on event without job: {event}")
        return

    containers = []
    oomkilled_containers = []
    running_containers = []

    """
    Retrieves pod's containers information
    """
    OOMKilled = "OOMKilled"
    for status in pod.status.containerStatuses:
        if status.state.running == None:
            if status.state.terminated.reason == OOMKilled:
                oomkilled_containers.append(status.name)
        else:
            running_containers.append(status.name)

    """
    Updating pod's containers resources if required
    """
    for container in pod.spec.containers:
        if container.name in oomkilled_containers:
            if container.resources.limits and container.resources.requests:
                req_memory = bitmath.parse_string_unsafe(container.resources.requests["memory"])
                max_resource = bitmath.parse_string_unsafe(params.max_resource)
                if req_memory < max_resource:
                    keep_the_same = False
                    containers.append(
                        increase_resource(
                            container,
                            max_resource,
                            params.increase_by,
                            keep_the_same,
                        )
                    )
                else:
                    finding.title = f"MAX REACHED"
                    finding.add_enrichment(
                        [
                            MarkdownBlock(
                                f"*container request memory has reached the limit*\n```\n{container.name}\n```"
                            ),
                        ]
                    )

                    keep_the_same = True
                    containers.append(
                        increase_resource(
                            container,
                            max_resource,
                            params.increase_by,
                            keep_the_same,
                        )
                    )
            else:
                logging.error(f"Container {container.name} does not have resources limits and requests defined.")
                return
        elif container.name in running_containers:
            keep_the_same = True
            containers.append(
                increase_resource(
                    container,
                    max_resource,
                    params.increase_by,
                    keep_the_same,
                )
            )

    job_spec = job_fields(job_event, containers)
    job_event.delete()
    job_spec.create()

    containers_memory_list = []

    # Getting information for finding
    for index, containers in enumerate(job_spec.spec.template.spec.containers):
        containers_memory_list.append(containers.name)
        containers_memory_list.append(containers.resources.requests["memory"])

    finding.add_enrichment(
        [
            MarkdownBlock(f"*containers memory after restart*\n```\n{containers_memory_list}\n```"),
        ]
    )
    event.add_finding(finding)

    This action will run when job failed with oomkilled
    
playbooks/robusta_playbooks/job_restart_on_oomkilled_community.py