Abort And Resurrect

# configurations
.idea

# crawlee and apify storage folders
apify_storage
crawlee_storage
storage

# installed files
node_modules

# git folder
.git

storage
node_modules

{
	"name": "actor-resurrect-with-new-input",
	"version": "0.0.1",
	"type": "module",
	"description": "This is an example of an Apify actor.",
	"dependencies": {
		"apify": "^3.0.0"
	},
	"devDependencies": {},
	"scripts": {
		"start": "node src/main.js",
		"test": "echo \"Error: oops, the actor has no tests yet, sad!\" && exit 1"
	},
	"author": "It's not you it's me",
	"license": "ISC"
}

# Specify the base Docker image. You can read more about
# the available images at https://sdk.apify.com/docs/guides/docker-images
# You can also use any other image from Docker Hub.
FROM apify/actor-node:16

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY package*.json ./

# Install NPM packages, skip optional and development dependencies to
# keep the image small. Avoid logging too much and print the dependency
# tree for debugging
RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version \
    && rm -r ~/.npm

# Next, copy the remaining files and directories with the source code.
# Since we do this after NPM install, quick build will be really fast
# for most source file changes.
COPY . ./


# Run the image.
CMD npm start --silent

{
	"actorSpecification": 1,
	"name": "abort-and-resurrect",
	"title": "Abort & Resurrect With New Input",
	"description": "Aborts selected actor or task runs ",
	"version": "0.0",
	"buildTag": "version-0",
	"input": "./input-schema.json"
}

{
  "title": "Actor input schema",
  "description": "This is actor input schema",
  "type": "object",
  "schemaVersion": 1,
  "properties": {
    "runIds": {
      "title": "Run IDs",
      "type": "array",
      "description": "IDs of individual runs you want to abort and resurrect.",
      "editor": "stringList",
      "default": []
    },
    "actorIds": {
      "title": "Actor IDs",
      "type": "array",
      "description": "When you provide an actor ID, all running runs of the actor will be aborted and resurrected.",
      "editor": "stringList",
      "default": []
    },
    "taskIds": {
      "title": "Task IDs",
      "type": "array",
      "description": "When you provide a task ID, all running runs of the task will be aborted and resurrected.",
      "editor": "stringList",
      "default": []
    },
    "transformInputSource": {
      "title": "Transform Input Function",
      "type": "string",
      "description": "This function will be used to transform the original input of the actor run into the new input. The `input` and `option` arguments are mutable and you should make your changes directly in the provided objects.",
      "editor": "javascript",
      "prefill": "function transformInput({ input, options }) {\n     input.foo = 'bar';\n     options.memory = 2048;\n }"
    }
  },
  "required": [
    "transformInputSource"
  ]
}

# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/

<?xml version="1.0" encoding="UTF-8"?>
<module type="WEB_MODULE" version="4">
  <component name="NewModuleRootManager">
    <content url="file://$MODULE_DIR$">
      <excludeFolder url="file://$MODULE_DIR$/temp" />
      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
      <excludeFolder url="file://$MODULE_DIR$/tmp" />
    </content>
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
</module>

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="JavaScriptLibraryMappings">
    <includedPredefinedLibrary name="Node.js Core" />
  </component>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/actor-resurrect-with-new-input.iml" filepath="$PROJECT_DIR$/.idea/actor-resurrect-with-new-input.iml" />
    </modules>
  </component>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="AutoImportSettings">
    <option name="autoReloadType" value="SELECTIVE" />
  </component>
  <component name="ChangeListManager">
    <list default="true" id="3df15837-a08d-4cd4-934f-7978ad5b076a" name="Changes" comment="" />
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
    <option name="LAST_RESOLUTION" value="IGNORE" />
  </component>
  <component name="MarkdownSettingsMigration">
    <option name="stateVersion" value="1" />
  </component>
  <component name="ProjectId" id="2LM98PiybFyoOanD9AfPLRS0ExL" />
  <component name="ProjectViewState">
    <option name="hideEmptyMiddlePackages" value="true" />
    <option name="showLibraryContents" value="true" />
  </component>
  <component name="PropertiesComponent"><![CDATA[{
  "keyToString": {
    "RunOnceActivity.OpenProjectViewOnStart": "true",
    "RunOnceActivity.ShowReadmeOnStart": "true",
    "WebServerToolWindowFactoryState": "false",
    "javascript.nodejs.core.library.configured.version": "16.16.0",
    "javascript.nodejs.core.library.typings.version": "16.18.12",
    "node.js.detected.package.eslint": "true",
    "node.js.detected.package.tslint": "true",
    "node.js.selected.package.eslint": "(autodetect)",
    "node.js.selected.package.tslint": "(autodetect)",
    "nodejs_package_manager_path": "npm",
    "ts.external.directory.path": "/Users/mnmkng/Library/Application Support/JetBrains/Toolbox/apps/WebStorm/ch-0/223.8617.44/WebStorm.app/Contents/plugins/javascript-impl/jsLanguageServicesImpl/external",
    "vue.rearranger.settings.migration": "true"
  }
}]]></component>
  <component name="RecentsManager">
    <key name="MoveFile.RECENT_KEYS">
      <recent name="$PROJECT_DIR$" />
    </key>
  </component>
  <component name="RunManager">
    <configuration name="main.js" type="NodeJSConfigurationType" temporary="true" nameIsGenerated="true" path-to-js-file="src/main.js" working-dir="$PROJECT_DIR$">
      <envs>
        <env name="APIFY_TOKEN" value="apify_api_iPPqEVeHrcqhYcFSFb4NXTnXqCixIm0SBRnJ" />
      </envs>
      <method v="2" />
    </configuration>
    <recent_temporary>
      <list>
        <item itemvalue="Node.js.main.js" />
      </list>
    </recent_temporary>
  </component>
  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
  <component name="TaskManager">
    <task active="true" id="Default" summary="Default task">
      <changelist id="3df15837-a08d-4cd4-934f-7978ad5b076a" name="Changes" comment="" />
      <created>1675669924902</created>
      <option name="number" value="Default" />
      <option name="presentableId" value="Default" />
      <updated>1675669924902</updated>
      <workItem from="1675669926072" duration="13837000" />
    </task>
    <servers />
  </component>
  <component name="TypeScriptGeneratedFilesManager">
    <option name="version" value="3" />
  </component>
  <component name="XDebuggerManager">
    <breakpoint-manager>
      <breakpoints>
        <line-breakpoint enabled="true" type="javascript">
          <url>file://$PROJECT_DIR$/src/utils.js</url>
          <line>19</line>
          <properties lambdaOrdinal="-1" />
          <option name="timeStamp" value="3" />
        </line-breakpoint>
        <line-breakpoint enabled="true" type="javascript">
          <url>file://$PROJECT_DIR$/src/utils.js</url>
          <line>69</line>
          <properties lambdaOrdinal="-1" />
          <option name="timeStamp" value="7" />
        </line-breakpoint>
        <line-breakpoint enabled="true" type="javascript">
          <url>file://$PROJECT_DIR$/src/utils.js</url>
          <line>74</line>
          <properties lambdaOrdinal="-1" />
          <option name="timeStamp" value="8" />
        </line-breakpoint>
      </breakpoints>
    </breakpoint-manager>
  </component>
</project>

1import { Actor } from 'apify';
2import { evalFunctionOrThrow, diff, fetchRuns, fetchTaskRuns, fetchActorRuns } from "./utils.js";
3
4await Actor.init();
5const client = Actor.newClient();
6
7const { runIds, actorIds, taskIds, transformInputSource } = await Actor.getInput();
8
9// PREP & VALIDATION
10/**
11 * @param {object} context
12 * @param {object} context.input
13 * @param {object} context.options
14 */
15const transformInput = evalFunctionOrThrow(transformInputSource);
16
17if (!(runIds.length || actorIds.length || taskIds.length)) {
18    throw new Error('Did not receive any run IDs, actor IDs or task IDs. Aborting.');
19}
20
21// FETCH RUNNING RUNS
22const collectedRuns = [];
23
24if (runIds.length) {
25    const runs = await fetchRuns(client, runIds);
26    console.log(`Fetched ${runs.length} runs based on their IDs.`);
27    collectedRuns.push(...runs);
28}
29
30if (actorIds.length) {
31    const runs = await fetchActorRuns(client, actorIds)
32    collectedRuns.push(...runs);
33}
34
35if (taskIds.length) {
36    const runs = await fetchTaskRuns(client, taskIds)
37    collectedRuns.push(...runs);
38}
39
40// TRANSFORM, ABORT, RESURRECT
41const processedRunPromises = collectedRuns.map(async (run) => {
42    const runClient = client.run(run.id);
43    const kvsClient = runClient.keyValueStore();
44
45    console.log(`[${run.id}] Fetching input.`);
46    const { value: input } = await kvsClient.getRecord('INPUT');
47    const newInput = JSON.parse(JSON.stringify(input));
48    // The run object contains the options in a different
49    // format than the API expects them in resurrect.
50    const apiOptions = {
51        build: run.options.build,
52        memory: run.options.memoryMbytes,
53        timeout: run.options.timeoutSecs,
54    }
55    const newOptions = { ...apiOptions };
56
57    console.log(`[${run.id}] Transforming input with transformInput function.`);
58    transformInput({
59        input: newInput,
60        options: newOptions,
61    })
62    const inputDiff = diff(input, newInput);
63    if (inputDiff) {
64        console.log(`[${run.id}] Changed input:`, inputDiff);
65    }
66    const optionsDiff = diff(apiOptions, newOptions);
67    if (optionsDiff) {
68        console.log(`[${run.id}] Changed options:`, optionsDiff);
69    }
70
71    console.log(`[${run.id}] Aborting run.`)
72    await runClient.abort({ gracefully: true });
73    // Graceful abort can take some time.
74    await runClient.waitForFinish();
75
76    console.log(`[${run.id}] Saving new input to key-value store.`)
77    await kvsClient.setRecord({
78        key: 'INPUT',
79        value: newInput,
80    })
81
82    console.log(`[${run.id}] Resurrecting run.`)
83    const resurrectedRun = await runClient.resurrect(newOptions);
84
85    console.log(`[${run.id}] Saving input and run information to dataset.`)
86    await Actor.pushData({
87        input,
88        newInput,
89        abortedRun: run,
90        resurrectedRun,
91    })
92})
93
94const processedRuns = await Promise.all(processedRunPromises);
95console.log(`Aborted and resurrected ${processedRuns.length} runs. The end.`);
96await Actor.exit();

1import vm from 'node:vm'
2
3export const fetchRuns = async (apifyClient, runIds) => {
4    const runPromises = runIds.map(async (runId) => {
5        return apifyClient.run(runId).get();
6    })
7    const runs = await Promise.all(runPromises);
8    return runs.filter(run => run.status === 'RUNNING');
9}
10
11export const fetchActorRuns = async (apifyClient, actorIds) => {
12    const runPromises = actorIds.map(async (actorId) => {
13        const { items } = await apifyClient.actor(actorId).runs().list({ status: 'RUNNING'});
14        const runIds = items.map(run => run.id);
15        const runs = await fetchRuns(apifyClient, runIds);
16        console.log(`Fetched ${runs.length} running runs of actor: ${actorId}`);
17        return runs;
18    })
19    const runsInArrays = await Promise.all(runPromises);
20    return runsInArrays.flat();
21}
22
23export const fetchTaskRuns = async (apifyClient, taskIds) => {
24    const runPromises = taskIds.map(async (taskId) => {
25        const { items } = await apifyClient.task(taskId).runs().list({ status: 'RUNNING'});
26        const runIds = items.map(run => run.id);
27        const runs = await fetchRuns(apifyClient, runIds);
28        console.log(`Fetched ${runs.length} running runs of actor: ${taskId}`);
29        return runs;
30    })
31    const runsInArrays = await Promise.all(runPromises);
32    return runsInArrays.flat();
33}
34
35/**
36 * Transforms a page function string into a Function object.
37 * @param {string} funcString
38 * @return {Function}
39 */
40export const evalFunctionOrThrow = (funcString) => {
41    let func;
42
43    try {
44        func = vm.runInThisContext(`(${funcString})`);
45    } catch (err) {
46        throw new Error(`Compilation of transformInput source code failed.\n${err.message}\n${err.stack.substr(err.stack.indexOf('\n'))}`);
47    }
48
49    if (typeof func !== 'function') throw new Error('`transformInput` function is not a function.');
50
51    return func;
52};
53
54/**
55 * Creates a diff between the first and second object.
56 * @param {object} obj1
57 * @param {object} obj2
58 * @returns {object|undefined}
59 */
60export const diff = (obj1, obj2) => {
61    const result = {};
62    if (Object.is(obj1, obj2)) {
63        return undefined;
64    }
65    if (!obj2 || typeof obj2 !== 'object') {
66        return obj2;
67    }
68    Object.keys(obj1 || {}).concat(Object.keys(obj2 || {})).forEach(key => {
69        if (obj2[key] !== obj1[key] && !Object.is(obj1[key], obj2[key])) {
70            result[key] = obj2[key];
71        }
72        if (typeof obj2[key] === 'object' && typeof obj1[key] === 'object') {
73            const value = diff(obj1[key], obj2[key]);
74            if (value !== undefined) {
75                result[key] = value;
76            }
77        }
78    });
79    // clean empty objects
80    for (const [k, v] of Object.entries(result)) {
81        if (!Object.keys(v).length) {
82            delete result[k];
83        }
84    }
85    return result;
86}