class TestVideoAbstraction(unittest.TestCase):
def setUp(self):
self.VideoObject = Video()
self.VideoObject.activate()
# self.VideoObject.valid = ValidateVideo(
# filepath=self.VideoObject.mezz_filepath
# ).valid
def test_video_object(self):
self.assertTrue(os.path.exists(self.VideoObject.mezz_filepath))
def test_video_validate(self):
self.assertTrue(self.VideoObject.valid)
class TestVideoAbstraction(unittest.TestCase):
def setUp(self):
self.VideoObject = Video()
self.VideoObject.activate()
# self.VideoObject.valid = ValidateVideo(
# filepath=self.VideoObject.mezz_filepath
# ).valid
def test_video_object(self):
self.assertTrue(os.path.exists(self.VideoObject.mezz_filepath))
def test_video_validate(self):
self.assertTrue(self.VideoObject.valid)
class Test_Encode_Command(unittest.TestCase):
def setUp(self):
self.WS = WorkerSetup()
if os.path.exists(self.WS.instance_yaml):
self.WS.run()
self.settings = self.WS.settings_dict
self.encode_profile = 'desktop_mp4'
"""
Gen abstractions
"""
# Video
self.VideoObject = Video(veda_id='XXXXXXXX2016-V00TEST', )
self.VideoObject.activate()
# Encode
self.E = Encode(VideoObject=self.VideoObject,
profile_name=self.encode_profile)
self.E.pull_data()
self.ffcommand = None
def test_generate_command(self):
if not os.path.exists(self.WS.instance_yaml):
self.assertTrue(True)
return None
"""
Generate the (shell) command / Encode Object
"""
self.assertTrue(self.VideoObject.valid is True)
# self.assertTrue(self.VideoObject.valid is True)
"""
Generate the Encode Object
"""
self.E.pull_data()
self.assertFalse(self.E.filetype is None)
"""
Generate the (shell) command
"""
self.ffcommand = CommandGenerate(VideoObject=self.VideoObject,
EncodeObject=self.E).generate()
self.assertFalse(self.ffcommand is None)
"""
class VedaWorker():
def __init__(self, **kwargs):
"""
Init settings /
"""
self.settings = None
self.veda_id = kwargs.get('veda_id', None)
self.setup = kwargs.get('setup', False)
self.jobid = kwargs.get('jobid', None)
"""#---#"""
self.encode_profile = kwargs.get('encode_profile', None)
self.VideoObject = None
"""
Yucky working directory stuff
"""
if self.jobid is None:
self.workdir = os.path.join(
homedir,
'ENCODE_WORKDIR'
)
else:
self.workdir = os.path.join(
homedir,
'ENCODE_WORKDIR',
self.jobid
)
if not os.path.exists(os.path.join(
homedir,
'ENCODE_WORKDIR'
)):
os.mkdir(os.path.join(
homedir,
'ENCODE_WORKDIR'
))
"""#---#"""
self.ffcommand = None
self.source_file = None
self.output_file = None
self.endpoint_url = None
"""Pipeline Steps"""
self.encoded = False
self.delivered = False
def test(self):
"""
Run tests
"""
current_dir = os.getcwd()
test_dir = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'tests'
)
os.chdir(test_dir)
test_bool = nose.run()
'''Return to previous state'''
os.chdir(current_dir)
return test_bool
def run(self):
WS = WorkerSetup()
if self.setup is True:
WS.setup = True
WS.run()
self.settings = WS.settings_dict
if self.encode_profile is None:
ErrorObject().print_error(
message = 'No Encode Profile Specified'
)
return None
self.VideoObject = Video(
veda_id=self.veda_id
)
self.VideoObject.activate()
if self.VideoObject.valid is False:
ErrorObject().print_error(
message = 'Invalid Video / VEDA Data'
)
return None
if not os.path.exists(self.workdir):
os.mkdir(self.workdir)
"""
Pipeline Steps :
I. Intake
Ib. Validate Mezz
II. change status in APIs
III. Generate Encode Command
IV. Execute Encodes
IVa. Validate Products
(*)V. Deliver Encodes (sftp and others?), retrieve URLs
(*)VI. Change Status in APIs, add URLs
VII. Clean Directory
"""
self._ENG_INTAKE()
if self.VideoObject.valid is False:
ErrorObject().print_error(
message = 'Invalid Video / Local'
)
return None
self._UPDATE_API()
if self.encode_profile == 'hls':
self._HLSPipeline()
else:
self._StaticPipeline()
print self.endpoint_url
if self.endpoint_url is not None:
"""
Integrate with main
"""
veda_id = self.veda_id
encode_profile = self.encode_profile
celeryapp.deliverable_route.apply_async(
(veda_id, encode_profile),
queue='transcode_stat'
)
"""
Clean up workdir
"""
if self.jobid is not None:
shutil.rmtree(
self.workdir
)
def _StaticPipeline(self):
self._GENERATE_ENCODE()
if self.ffcommand is None:
print 'No Command'
return None
self._EXECUTE_ENCODE()
self._VALIDATE_ENCODE()
if self.encoded is True:
self._DELIVER_FILE()
def _HLSPipeline(self):
"""
Activate HLS, use hls lib to upload
"""
if not os.path.exists(os.path.join(self.workdir, self.source_file)):
ErrorObject().print_error(
message = 'Source File (local) NOT FOUND',
)
return None
os.chdir(self.workdir)
V1 = VHLS(
mezz_file=os.path.join(self.workdir, self.source_file),
DELIVER_BUCKET=self.settings['edx_s3_endpoint_bucket'],
ACCESS_KEY_ID=self.settings['edx_access_key_id'],
SECRET_ACCESS_KEY = self.settings['edx_secret_access_key']
)
if V1.complete is True:
self.endpoint_url = V1.manifest_url
else:
return None
def _ENG_INTAKE(self):
"""
Copy file down from AWS S3 storage bucket
"""
if self.VideoObject.valid is False:
ErrorObject().print_error(
message = 'Invalid Video'
)
return None
conn = S3Connection(
self.settings['aws_access_key'],
self.settings['aws_secret_key']
)
try:
bucket = conn.get_bucket(self.settings['aws_storage_bucket'])
except:
ErrorObject().print_error(
message = 'Invalid Storage Bucket'
)
return None
self.source_file = '.'.join((
self.VideoObject.veda_id,
self.VideoObject.mezz_extension
))
source_key = bucket.get_key(self.source_file)
if source_key == None:
ErrorObject().print_error(
message = 'S3 Intake Object NOT FOUND',
)
return None
source_key.get_contents_to_filename(
os.path.join(self.workdir, self.source_file)
)
if not os.path.exists(os.path.join(self.workdir, self.source_file)):
ErrorObject().print_error(
message = 'Engine Intake Download',
)
return None
self.VideoObject.valid = ValidateVideo(
filepath=os.path.join(self.workdir, self.source_file)
).valid
def _UPDATE_API(self):
V2 = UpdateAPIStatus(
val_video_status=VAL_TRANSCODE_STATUS,
veda_video_status=NODE_TRANSCODE_STATUS,
VideoObject=self.VideoObject,
).run()
def _GENERATE_ENCODE(self):
"""
Generate the (shell) command / Encode Object
"""
E = Encode(
VideoObject=self.VideoObject,
profile_name=self.encode_profile
)
E.pull_data()
if E.filetype is None: return None
"""
Implement HLS Here
"""
self.ffcommand = CommandGenerate(
VideoObject = self.VideoObject,
EncodeObject = E,
jobid=self.jobid
).generate()
def _EXECUTE_ENCODE(self):
"""
if this is just a filepath, this should just work
--no need to move the source--
"""
if not os.path.exists(
os.path.join(self.workdir, self.source_file)
):
ErrorObject().print_error(
message = 'Source File (local) NOT FOUND',
)
return None
process = subprocess.Popen(
self.ffcommand,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=True,
universal_newlines=True
)
print '%s : %s' % (self.VideoObject.veda_id, self.encode_profile)
Output.status_bar(process=process)
# to be polite
print
self.output_file = self.ffcommand.split('/')[-1]
if not os.path.exists(
os.path.join(self.workdir, self.output_file)
):
ErrorObject().print_error(
message = 'Source File (local) NOT FOUND',
)
def _VALIDATE_ENCODE(self):
"""
Validate encode by matching (w/in 5 sec) encode duration,
as well as standard validation tests
"""
self.encoded = ValidateVideo(
filepath=os.path.join(self.workdir, self.output_file),
product_file=True,
VideoObject=self.VideoObject
).valid
def _DELIVER_FILE(self):
"""
Deliver Here // FOR NOW: go to the
"""
if not os.path.exists(
os.path.join(self.workdir, self.output_file)
):
return None
D1 = Deliverable(
VideoObject=self.VideoObject,
encode_profile=self.encode_profile,
output_file=self.output_file,
jobid=self.jobid
)
D1.run()
self.delivered = D1.delivered
self.endpoint_url = D1.endpoint_url