@eluvio/elv-client-js 4.0.10 → 4.0.12

package/testScripts/CreateMezMonolithic.js

@@ -1,779 +0,0 @@
-/* eslint-disable no-console */
-
-const R = require("ramda");
-const curry = require("crocks/helpers/curry");
-const pipe = require("crocks/helpers/pipe");
-
-const {
-  ObjectModel,
-  NonNegativeInteger,
-  PositiveInteger
-} = require("../utilities/lib/models/Models");
-
-
-const MP4AtomReadContextModel = ObjectModel(
-  {
-    buffer: Buffer,
-    currentAtomLength: PositiveInteger,
-    currentAtomStart: NonNegativeInteger,
-    posWithinAtom: NonNegativeInteger
-  })
-  .assert(x => x.currentAtomLength >= 8, ()=>"currentAtomLength must be >= 8")
-  .assert(x => x.posWithinAtom < x.currentAtomLength, ()=>"posWithinAtom must be < currentAtomLength")
-  .assert(x => (x.currentAtomStart + x.currentAtomLength) <= x.buffer.length,()=> "currentAtomStart + currentAtomLength must be <= buffer.length");
-
-class MP4AtomReadContext extends MP4AtomReadContextModel
-{
-
-  get currentAtomBytesLeft() {
-    return this.currentAtomLength - this.posWithinAtom;
-  }
-
-  get currentAtomEnd() {
-    return this.currentAtomStart + this.currentAtomLength;
-  }
-
-  get currentBufPos() {
-    return this.currentAtomStart + this.posWithinAtom;
-  }
-}
-
-// enter atom under read head, then move read head past header (length and type fields)
-const enter = readContext => {
-  let {atomType, atomLength, headerLength} = readHeader(readContext);
-  // logger.log(`Entering atom '${atomType}', atom start = ${readContext.currentBufPos}, skipping ${headerLength} byte header`);
-  return new MP4AtomReadContext(
-    {
-      buffer: readContext.buffer,
-      currentAtomLength: atomLength,
-      currentAtomStart: readContext.currentBufPos,
-      currentAtomType: atomType,
-      posWithinAtom: headerLength
-    }
-  );
-};
-
-// Read atoms without entering, looking for particular atom atomType(s)
-// The read head must be at the start of any atom (reading the next 4 bytes must return the length field)
-const find = curry(
-  (atomTypes, readContext) => {
-    let eof = false;
-    let found = false;
-    while(!found && !eof) {
-      let {atomType, atomLength} = readHeader(readContext);
-      if(atomTypes.includes(atomType)) {
-        found = true;
-      } else {
-        // skip to next atom
-        readContext = moveWithin(atomLength, readContext);
-        // check if we have run out of data
-        if(readContext.posWithinAtom === readContext.currentAtomLength) eof = true;
-      }
-    }
-    if(!found) throw Error(`Atom type(s) not found: ${atomTypes}`);
-
-    return readContext;
-  }
-);
-
-const findAndEnter = curry(
-  (atomTypes, readContext) => {
-    return enter(find(atomTypes, readContext));
-  }
-);
-
-const moveWithin = curry(
-  (offset, readContext) => {
-    // logger.log(`Move within atom: ${offset} bytes`);
-
-    const newPosWithinParent = readContext.posWithinAtom + offset;
-    if(newPosWithinParent >= readContext.currentAtomLength) throw Error("Cannot move past end of atom");
-    if(newPosWithinParent < 0) throw Error("Cannot move before beginning of atom");
-    return new MP4AtomReadContext({
-      buffer: readContext.buffer,
-      currentAtomLength: readContext.currentAtomLength,
-      currentAtomStart: readContext.currentAtomStart,
-      currentAtomType: readContext.currentAtomType,
-      posWithinAtom: newPosWithinParent
-    });
-  }
-);
-
-
-const newContextFromBuffer = buffer => {
-  return new MP4AtomReadContext({
-    buffer,
-    currentAtomLength: buffer.length,
-    currentAtomStart: 0,
-    currentAtomType: "",
-    posWithinAtom: 0
-  });
-};
-
-const readAtom = readContext => {
-  const {atomLength} = readHeader(readContext);
-  const atomStart = readContext.currentBufPos;
-  const atomEnd = atomStart + atomLength;
-  return readContext.buffer.subarray(atomStart, atomEnd);
-};
-
-const readHeader = readContext => {
-  const {buffer, currentAtomBytesLeft, currentBufPos} = readContext;
-  let headerLength = 8;
-
-  if(currentAtomBytesLeft < headerLength) throw Error("Cannot read atom, not enough bytes available to hold atomLength + type fields");
-
-  // read 4 bytes to get atomLength
-  let atomLength = buffer.readUInt32BE(currentBufPos);
-  if(atomLength === 0 || (atomLength > 1 && atomLength < 8)) throw Error(`Invalid length 0 found: ${atomLength}`);
-
-  // read 4 bytes to get atom type
-  const atomType = buffer.toString("ascii", currentBufPos + 4, currentBufPos + 8);
-
-  // if atomLength === 1, need to read 8 more bytes to get 64-bit atomLength
-  if(atomLength === 1) {
-    headerLength = 16;
-    if(currentAtomBytesLeft < headerLength) throw Error("Cannot read atom, not enough bytes available to hold 64-bit atomLength field");
-    atomLength = buffer.readUInt64BE(currentBufPos + 8);
-  }
-
-  if(atomLength > currentAtomBytesLeft) {
-    throw Error(`Invalid length found: ${atomLength} (only ${currentAtomBytesLeft} available)`);
-  }
-
-  return {atomLength, atomType, headerLength};
-};
-
-module.exports = {
-  enter,
-  find,
-  findAndEnter,
-  moveWithin,
-  MP4AtomReadContext,
-  newContextFromBuffer,
-  readAtom,
-  readHeader
-};
-
-
-
-// takes buffer containing MP4 init segment (or entire MP4 file) for a single x264/x265 video stream
-// and returns codec descriptor string (e.g. "avc1.640028", "hev1.2.4.L150.90" etc.)
-const codecDesc = buffer => {
-  let resultContext = decoderConfigAtom(buffer);
-  let {atomLength, atomType, headerLength} = readHeader(resultContext);
-
-  // make new buffer that omits header (length and type fields)
-  const decoderBodyBuf = resultContext.buffer.subarray(headerLength, atomLength);
-  switch(atomType) {
-    case "avcC":
-      return x264codecString(decoderBodyBuf);
-    case "hvcC":
-      return x265codecString(decoderBodyBuf);
-    default:
-      throw Error(`Unknown decoder configuration atom type: '${atomType}'`);
-  }
-};
-
-// buffer containing init segment -> MP4AtomReadContext with buffer containing only avcC or hvcC atom
-const decoderConfigAtom = pipe(
-  newContextFromBuffer,
-  findAndEnter(["moov"]),
-  findAndEnter(["trak"]),
-  findAndEnter(["mdia"]),
-  findAndEnter(["minf"]),
-  findAndEnter(["stbl"]),
-  findAndEnter(["stsd"]),
-  moveWithin(8),
-  findAndEnter(["avc1", "encv", "hev1"]),
-  moveWithin(78),
-  find(["avcC", "hvcC"]),
-  readAtom,
-  newContextFromBuffer
-);
-
-// takes buffer containing decoder config atom (without the type/length fields at front) and returns x264 codec string
-const x264codecString = atomBodyBuf => {
-  // See https://dvb.org/wp-content/uploads/2019/10/a168_DVB_MPEG-DASH_Nov_2017.pdf
-
-  if(atomBodyBuf.length < 4) throw Error("Not enough bytes in AVCDecoderConfiguration");
-
-  const avcProfileIndication = atomBodyBuf.readUInt8(1).toString(16).padStart(2, "0");
-  const profileCompatibility = atomBodyBuf.readUInt8(2).toString(16).padStart(2, "0");
-  const avcLevelIndication = atomBodyBuf.readUInt8(3).toString(16).padStart(2, "0");
-  return `avc1.${avcProfileIndication}${profileCompatibility}${avcLevelIndication}`;
-};
-
-// takes buffer containing decoder config atom (without the type/length fields at front) and returns x265 codec string
-const x265codecString = atomBodyBuf => {
-  // See https://dvb.org/wp-content/uploads/2019/10/a168_DVB_MPEG-DASH_Nov_2017.pdf
-
-  if(atomBodyBuf.length < 13) throw Error("Not enough bytes in HVCDecoderConfiguration");
-
-  // parse bytes/bits into values
-  const bitFlags = atomBodyBuf.readUInt8(1);
-  const genProfileSpaceBits = (bitFlags & 0b11000000) >>> 6;
-  const genTierBit = (bitFlags & 0b00100000) >>> 5;
-  const genProfileIDC = bitFlags & 0b00011111;
-  const genProfileCompatibility = parseInt(R.reverse(atomBodyBuf.readUInt32BE(2).toString(2).padStart(32, "0")), 2).toString(16);
-  let genConstraintFlags = [
-    atomBodyBuf.readUInt8(6),
-    atomBodyBuf.readUInt8(7),
-    atomBodyBuf.readUInt8(8),
-    atomBodyBuf.readUInt8(9),
-    atomBodyBuf.readUInt8(10),
-    atomBodyBuf.readUInt8(11)
-  ];
-  const genLevelIDC = atomBodyBuf.readUInt8(12);
-
-  // Format values into appropriate strings
-
-  // CODECSTRING = CODEC "." PROFILE "." LEVEL "." CONSTRAINTS
-
-  // CODEC = ("hev1" | "hvc1" )
-  let pieces = ["hev1"];
-
-  // PROFILE = PROFILE_SPACE PROFILE_IDC "." PROFILE_COMPATIBILITY
-
-  // PROFILE_SPACE = "" | "A" | "B" | "C" (for general_profile_space values 0,1,2,3)
-  let profileSpace = "";
-  switch(genProfileSpaceBits){
-    case 1:
-      profileSpace = "A";
-      break;
-    case 2:
-      profileSpace = "B";
-      break;
-    case 3:
-      profileSpace = "C";
-      break;
-  }
-
-  // PROFILE_IDC is a decimal number, PROFILE_COMPATIBILITY is a hex string
-  const profile = `${profileSpace}${genProfileIDC}.${genProfileCompatibility}`;
-  pieces.push(profile);
-
-  // LEVEL = TIER LEVEL_IDC
-
-  // TIER = "L" / "H" (general_tier_flag, 0=="L", 1=="H")
-  const tier = genTierBit ? "H" : "L";
-  const level = `${tier}${genLevelIDC}`;
-  pieces.push(level);
-
-  // CONSTRAINTS = 2(HEXDIG) [ "." CONSTRAINTS ] (hexadecimal representation of the general_constraint_indicator_flags. Each byte is separated by a '.', and trailing zero bytes may be omitted.)
-
-  while(genConstraintFlags.length > 0 && genConstraintFlags.slice(-1)[0] === 0) {
-    genConstraintFlags.pop();
-  }
-  const constraints = genConstraintFlags.map(x => x.toString(16)).join(".");
-  pieces.push(constraints);
-
-  return pieces.join(".");
-};
-
-
-
-const setCodecDescs = async ({elvClient, libraryId, objectId, offeringKey, offeringMetadata, writeToken}) => {
-
-  // get first available playout format (for constructing init segment urls)
-  const formats = offeringMetadata.playout.playout_formats;
-  const firstFormatKey = Object.keys(formats)[0];
-  const player_profile = formats[firstFormatKey].drm && formats[firstFormatKey].drm.type === "DrmAes128" ?
-    "hls-js" :
-    "";
-
-  // find video streams, request init segments, set codec_desc
-  for(const [streamKey, stream] of Object.entries(offeringMetadata.media_struct.streams)) {
-    if(stream.codec_type === "video") {
-      console.log(`constructing codec strings for stream '${streamKey}'...`);
-      // get bitrate ladder
-      const reps = offeringMetadata.playout.streams[streamKey].representations;
-      for(const [repKey, rep] of R.sortBy(x => -x[1].bit_rate, Object.entries(reps))) {
-        const initSegUrl = `playout/${offeringKey}/${firstFormatKey}/${streamKey}/${repKey}/init.m4s`;
-        console.log("\n>> calling ElvClient.FabricUrl() with noAuth: false\n");
-        const url = new URL(
-          await elvClient.FabricUrl({
-            libraryId,
-            objectId,
-            rep: initSegUrl,
-            writeToken,
-            noAuth: false,
-          })
-        );
-
-        const path = url.pathname;
-        let queryParams = {
-          authorization: url.searchParams.get("authorization")
-        };
-        if(player_profile) queryParams.player_profile = player_profile;
-
-        console.log(`\n\nretrieving init segment @ ${url.href}\n`);
-        console.log(`queryParams: ${JSON.stringify(queryParams)}\n\n`);
-
-        // get init segment
-        const response = await elvClient.HttpClient.Request({
-          path,
-          queryParams,
-          method: "GET"
-        });
-        const buffer = Buffer.from(await response.arrayBuffer());
-
-        console.log(`constructing codec desc... ${repKey}`);
-
-        // make codec desc based on init seg
-        rep.codec_desc = codecDesc(buffer);
-      }
-    }
-  }
-
-  return {};
-};
-
-
-
-const Utils = require("../src/Utils");
-
-const preFinalizeFn = async ({elvClient, nodeUrl, writeToken}) => {
-
-  console.log(`\n\npreFinalizeFn() nodeUrl: ${JSON.stringify(nodeUrl,null,2)} writeToken: ${JSON.stringify(writeToken,null,2)}`);
-
-  const objectId = Utils.DecodeWriteToken(writeToken).objectId;
-  const libraryId = await elvClient.ContentObjectLibraryId({objectId});
-
-  // make sure client knows proper node to contact
-  elvClient.HttpClient.RecordWriteToken(writeToken, nodeUrl);
-
-  // get metadata from draft
-  const abrMezOfferingsMetadata = await elvClient.ContentObjectMetadata({
-    libraryId,
-    metadataSubtree: "/abr_mezzanine/offerings",
-    objectId,
-    writeToken
-  });
-
-  if(!abrMezOfferingsMetadata) throw Error("codecDescPrefinalizeFn: null metadata /abr_mezzanine/offerings from draft");
-
-  // get offering keys (there will be more than one if addlOfferingSpecs was used)
-  const offeringKeys = Object.keys(abrMezOfferingsMetadata);
-  if(offeringKeys.length === 0) throw Error("codecDescPrefinalizeFn: no offering keys found in draft's /abr_mezzanine/offerings");
-
-  // construct new metadata with codec descriptions included
-  const newAbrMezOffMetadata = {};
-  for(const offeringKey of offeringKeys) {
-    newAbrMezOffMetadata[offeringKey] = await setCodecDescs({
-      elvClient,
-      libraryId,
-      objectId,
-      offeringKey,
-      offeringMetadata: abrMezOfferingsMetadata[offeringKey],
-      writeToken
-    });
-  }
-
-  console.log("WRITING BACK TO METADATA...");
-
-  // write metadata back to draft
-  await elvClient.ReplaceMetadata({
-    libraryId,
-    metadata: newAbrMezOffMetadata,
-    metadataSubtree: "/abr_mezzanine/offerings",
-    objectId,
-    writeToken
-  });
-
-};
-
-
-/* eslint-disable no-console */
-const ScriptBase = require("./parentClasses/ScriptBase");
-ScriptBase.deprecationNotice("MezzanineCreate.js");
-
-
-const {ElvClient} = require("../src/ElvClient");
-const readline = require("readline");
-const fs = require("fs");
-
-const yargs = require("yargs");
-const argv = yargs
-  .option("library", {
-    description: "ID of the library in which to create the mezzanine"
-  })
-  .option("masterHash", {
-    description: "Version hash of the master object"
-  })
-  .option("type", {
-    description: "Name, object ID, or version hash of the type for the mezzanine"
-  })
-  .option("name", {
-    description: "Name for the mezzanine object (derived from ip-title-id and title if not provided)"
-  })
-  .option("title", {
-    description: "Title for the mezzanine"
-  })
-  .option("display-title", {
-    description: "Display title for the mezzanine (set to title if not specified)"
-  })
-  .option("slug", {
-    description: "Slug for the mezzanine (generated based on title if not specified)"
-  })
-  .option("ip-title-id", {
-    description: "IP title ID for the mezzanine (equivalent to slug if not specified)",
-    type: "string"
-  })
-  .option("title-type", {
-    description: "Title type for the mezzanine",
-    default: "title"
-  })
-  .option("asset-type", {
-    description: "Asset type for the mezzanine",
-    default: "primary"
-  })
-  .option("addlOfferingSpecs", {
-    description: "Additional offerings to create via patching - JSON string (or file path if prefixed with '@')"
-  })
-  .option("metadata", {
-    description: "Metadata JSON string (or file path if prefixed with '@') to include in the object metadata"
-  })
-  .option("variant", {
-    description: "Variant of the mezzanine",
-    default: "default"
-  })
-  .option("offering-key", {
-    description: "Offering key for the new mezzanine",
-    default: "default"
-  })
-  .option("existingMezzId", {
-    description: "If using an existing object to store mezzanine offering, the ID of that object",
-    type: "string"
-  })
-  .option("keep-other-streams", {
-    description: "If using an existing object to store mezzanine offering, and offering already exists,whether to preserve other streams",
-    default: false,
-    type: "boolean",
-  })
-  .option("stream-keys", {
-    description: "If supplied, only the specified stream(s) will be processed",
-    string: true,
-    type: "array",
-  })
-  .option("abr-profile", {
-    description: "Path to JSON file containing alternative ABR profile"
-  })
-  .option("elv-geo", {
-    type: "string",
-    description: "Geographic region for the fabric nodes. Available regions: na-west-north, na-west-south, na-east, eu-west, eu-east, as-east, au-east"
-  })
-  .option("config-url", {
-    type: "string",
-    description: "URL pointing to the Fabric configuration. i.e. https://main.net955210.contentfabric.io/config"
-  })
-  .option("credentials", {
-    type: "string",
-    description: "Path to JSON file containing credential sets for files stored in cloud"
-  })
-  .option("debug", {
-    type: "boolean",
-    description: "Enable client logging"
-  })
-  .option("wait", {
-    type: "boolean",
-    description: "Wait for mezzanine to finish transcoding, then finalize before exiting script"
-  })
-  .demandOption(
-    ["library", "masterHash", "type"],
-    "\nUsage: PRIVATE_KEY=<private-key> node CreateABRMezzanine.js --library <mezzanine-library-id> --type <type> </type>--masterHash <production-master-hash> --title <title> (--variant <variant>) (--metadata '<metadata-json>') (--addlOfferingSpecs '<specs-json>') (--existingMezzId <object-id>) (--elv-geo eu-west)\n"
-  )
-  .strict().argv;
-
-const ClientConfiguration = (!argv["config-url"]) ? (require("../TestConfiguration.json")) : {"config-url": argv["config-url"]};
-
-const Slugify = str =>
-  (str || "").toLowerCase().replace(/ /g, "-").replace(/[^a-z0-9-]/g, "");
-
-const Report = response => {
-  if(response.errors.length > 0) {
-    console.error("Errors:");
-    console.error(response.errors.join("\n"), "\n");
-  }
-
-  if(response.warnings.length) {
-    console.warn("Warnings:");
-    console.warn(response.warnings.join("\n"), "\n");
-  }
-};
-
-const Create = async (
-  {
-    library,
-    masterHash,
-    type,
-    variant,
-    offeringKey,
-    name,
-    title,
-    displayTitle,
-    slug,
-    ipTitleId,
-    titleType,
-    assetType,
-    metadata,
-    addlOfferingSpecs,
-    existingMezzId,
-    abrProfile,
-    elvGeo,
-    credentials,
-    debug,
-    wait = false,
-    keepOtherStreams,
-    streamKeys
-  }
-) => {
-
-  if(!existingMezzId && (keepOtherStreams)) {
-    throw Error("--existingMezzId required when using --keepOtherStreams");
-  }
-
-  if(addlOfferingSpecs && !abrProfile) {
-    throw Error("--abrProfile required when using --addlOfferingSpecs");
-  }
-
-  // force ipTitleId to be a string, if present
-  if(ipTitleId) {
-    ipTitleId = ipTitleId.toString();
-  }
-
-  try {
-    const privateKey = process.env.PRIVATE_KEY;
-    if(!privateKey) {
-      console.error("PRIVATE_KEY environment variable must be specified");
-      return;
-    }
-
-    if(!existingMezzId && !title) {
-      throw Error("--title argument is required unless --existingMezzId is specified");
-    }
-
-    const client = await ElvClient.FromConfigurationUrl({
-      configUrl: ClientConfiguration["config-url"],
-      region: elvGeo
-    });
-
-    let wallet = client.GenerateWallet();
-    let signer = wallet.AddAccount({
-      privateKey: process.env.PRIVATE_KEY
-    });
-
-    await client.SetSigner({signer});
-
-    if(debug) {
-      client.ToggleLogging(true);
-    }
-
-    // construct metadata
-    if(metadata) {
-      try {
-        if(metadata.startsWith("@")) {
-          metadata = fs.readFileSync(metadata.substring(1));
-        }
-
-        metadata = JSON.parse(metadata) || {};
-        if(!metadata.public) {
-          metadata.public = {};
-        }
-
-        name = name || metadata.public.name || metadata.name;
-      } catch(error) {
-        console.error("Error parsing metadata:");
-        console.error(error);
-        return;
-      }
-    } else if(existingMezzId) {
-      const libraryId = await client.ContentObjectLibraryId({objectId: existingMezzId});
-      const assetMetadata = (await client.ContentObjectMetadata({
-        libraryId,
-        objectId: existingMezzId,
-        metadataSubtree: "public/asset_metadata"
-      })) || {};
-
-      const existingName = (await client.ContentObjectMetadata({
-        libraryId,
-        objectId: existingMezzId,
-        metadataSubtree: "public/name"
-      })) || {};
-
-      metadata = {
-        public: {
-          asset_metadata: assetMetadata || {},
-          name: name || existingName || ""
-        }
-      };
-
-      if(!title && !metadata.public.asset_metadata.title) {
-        throw Error("Existing mez does not have 'title' set and title argument was not provided");
-      }
-    } else {
-      metadata = {public: {asset_metadata: {}}};
-    }
-
-    if(abrProfile) {
-      abrProfile = JSON.parse(fs.readFileSync(abrProfile));
-    }
-
-    if(addlOfferingSpecs) {
-      try {
-        if(addlOfferingSpecs.startsWith("@")) {
-          addlOfferingSpecs = fs.readFileSync(addlOfferingSpecs.substring(1));
-        }
-
-        addlOfferingSpecs = JSON.parse(addlOfferingSpecs) || undefined;
-      } catch(error) {
-        console.error("Error parsing addlOfferingSpecs:");
-        console.error(error);
-        return;
-      }
-    }
-
-    metadata.public.asset_metadata = {
-      title,
-      display_title: displayTitle || title,
-      slug: slug || Slugify(displayTitle || title),
-      ip_title_id: ipTitleId || slug || Slugify(displayTitle || title),
-      title_type: titleType,
-      asset_type: assetType,
-      ...(metadata.public.asset_metadata || {})
-    };
-
-    name = name || metadata.public.name || metadata.public.asset_metadata.title + " MEZ";
-
-    let access;
-    if(credentials) {
-      access = JSON.parse(fs.readFileSync(credentials));
-    } else {
-      access = [
-        {
-          path_matchers: [".*"],
-          remote_access: {
-            protocol: "s3",
-            platform: "aws",
-            path: process.env.AWS_BUCKET + "/",
-            storage_endpoint: {
-              region: process.env.AWS_REGION
-            },
-            cloud_credentials: {
-              access_key_id: process.env.AWS_KEY,
-              secret_access_key: process.env.AWS_SECRET
-            }
-          }
-        }
-      ];
-    }
-
-    const originalType = type;
-    if(type.startsWith("iq__")) {
-      type = await client.ContentType({typeId: type});
-    } else if(type.startsWith("hq__")) {
-      type = await client.ContentType({versionHash: type});
-    } else {
-      type = await client.ContentType({name: type});
-    }
-
-    if(!type) {
-      throw Error(`Unable to find content type "${originalType}"`);
-    }
-
-    type = type.hash;
-
-    console.log("\nCreating ABR Mezzanine...");
-    const createResponse = await client.CreateABRMezzanine({
-      name,
-      libraryId: library,
-      objectId: existingMezzId,
-      type,
-      masterVersionHash: masterHash,
-      variant,
-      offeringKey: offeringKey,
-      metadata,
-      addlOfferingSpecs,
-      abrProfile,
-      keepOtherStreams,
-      streamKeys
-    });
-
-    Report(createResponse);
-
-    const objectId = createResponse.id;
-
-    console.log("Starting Mezzanine Job(s)");
-
-    const startResponse = await client.StartABRMezzanineJobs({
-      libraryId: library,
-      objectId,
-      offeringKey,
-      access
-    });
-
-    Report(startResponse);
-
-    console.log("\nLibrary ID", library);
-    console.log("Object ID", objectId);
-    console.log("Offering:", offeringKey);
-    console.log("Write Token:", startResponse.lro_draft.write_token);
-    console.log("Write Node:", startResponse.lro_draft.node, "\n");
-
-    if(!wait) {
-      return;
-    }
-
-    console.log("Progress:");
-
-    // eslint-disable-next-line no-constant-condition
-    while(true) {
-      const status = await client.LROStatus({libraryId: library, objectId, offeringKey});
-
-      let done = true;
-      const progress = Object.keys(status).map(id => {
-        const info = status[id];
-
-        if(!info.end) {
-          done = false;
-        }
-
-        if(done && info.run_state !== "finished") {
-          throw Error(`LRO ${id} failed with status ${info.run_state}`);
-        }
-
-        return `${id}: ${parseFloat(info.progress.percentage || 0).toFixed(1)}%`;
-      });
-
-      readline.clearLine(process.stdout, 0);
-      readline.cursorTo(process.stdout, 0, null);
-      process.stdout.write(progress.join(" "));
-
-      if(done) {
-        break;
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 10000));
-    }
-
-    const finalizeResponse = await client.FinalizeABRMezzanine({
-      libraryId: library,
-      objectId,
-      offeringKey: offeringKey,
-      preFinalizeThrow: true,
-      preFinalizeFn // Before object is finalized, try to set codec descriptors
-    });
-
-    Report(finalizeResponse);
-
-    console.log("\n\nABR mezzanine object created:");
-    console.log("\tObject ID:", objectId);
-    console.log("\tVersion Hash:", finalizeResponse.hash, "\n");
-  } catch(error) {
-    console.error("Error creating mezzanine:");
-    console.error(error.body ? JSON.stringify(error, null, 2) : error);
-  }
-};
-
-
-Create(argv);