M*A*S*H Archive

M*A*S*H Archive

MASH ARCHIVE

4077 MASH UNIT ARCHIVE

https://4077.stream

Problem

Solutions

#!/bin/bash

# First argument
ID=$1

# Read the list into a variable[list]
readarray -t list < /home/4077/encoder/list.txt

# Use the instance id (itorator) as the postition  
EPISODE=${list[ID]}

# Print out the episode name for cloudinit logs
echo $EPISODE

echo "Starting file download."
rclone copy filebase:BUCKET_URL/${EPISODE}.mkv /home/4077/encoder/downloads/
echo "Finished file download."

echo "Starting conversion."
ffmpeg -i /home/4077/encoder/downloads/${EPISODE}.mkv -vcodec libvpx-vp9 -b:v 1M -acodec
 libvorbis /home/4077/encoder/output/${EPISODE}.webm
 echo "Finished conversion"

 echo "Starting file download deletion."
 rm /home/4077/encoder/downloads/${EPISODE}
 echo "Finished file download deletion."

 echo "Starting file upload."
 rclone copy /home/4077/encoder/output/${EPISODE}.webm filebase:BUCKET_URL/web/
 echo "Finished file upload."

S01E01
S01E02
E01E03

import sys
import json
import os
import provisioners
import subprocess
import pulumi
import pulumi_aws as aws
from pulumi import automation as auto
from pulumi_aws import s3

# Get the config ready to go.
config = pulumi.Config()

# If keyName is provided, an existing KeyPair is used, else if publicKey is provided a new KeyPair
# derived from the publicKey is created.
key_name = config.get('keyName')
public_key = config.get('publicKey')

# The privateKey associated with the selected key must be provided (either directly or base64 encoded),
# along with an optional passphrase if needed.
def decode_key(key):

    try:
        key = base64.b64decode(key.encode('ascii')).decode('ascii')
    except:
        pass

    if key.startswith('-----BEGIN RSA PRIVATE KEY-----'):
        return key

    return key.encode('ascii')

private_key = config.require_secret('privateKey').apply(decode_key)

secgrp = aws.ec2.SecurityGroup('secgrp',
    description='Foo',
    ingress=[
        aws.ec2.SecurityGroupIngressArgs(protocol='tcp', from_port=22, to_port=22, cidr_blocks=['0.0.0.0/0']),
        aws.ec2.SecurityGroupIngressArgs(protocol='tcp', from_port=80, to_port=80, cidr_blocks=['0.0.0.0/0']),
    ],
    egress=[aws.ec2.SecurityGroupEgressArgs(
                from_port=0,
                to_port=0,
                protocol="-1",
                cidr_blocks=["0.0.0.0/0"],
                ipv6_cidr_blocks=["::/0"],
    )],
)

ami = "ami-XXXXXXXXXXXXXXXXXXXX"

if key_name is None:
    key = aws.ec2.KeyPair('key', public_key=public_key)
    key_name = key.key_name

episodes = 251
for i in range(0, episodes):
    user_data = f"""
    #!/bin/bash
    /home/4077/encoder/encoder.sh {i} 
    """
    encoder = aws.ec2.Instance(f"encoder-{i}",
                                 ami=ami,
                                 instance_type="t2.large",
                                 user_data=user_data,
                                 key_name=key_name,
                                 vpc_security_group_ids=[ secgrp.id ],
                                 associate_public_ip_address=True,
                                 tags={
                                     "Name": f"{i}-encoder",
                                 })

1. Let me start an instance in a size of my choosing, and run one command on that instance to start the conversion, and let me snoop on the progress over SSH

2. Not have to download every episode and store it on EFS beforehand, which costs $$$.

3. Control the entire deployment pipeline of each instance using a simple [pulumi](https://www.pulumi.com/) script and a for loop.

Little swarms of computers

Continuation

• Instance Size

• Multithreading/Multicore processing

• ffmpeg options
• Best quality
• Best speed
• Best resolution
• Compromise

• Highest CPU utilization

• GPU-Intensive video transcoding?

Screenshots