def start_converting(youtube_id,
gcs_url,
formats_to_create,
base_url=BASE_URL):
# TODO(csilvers): figure out how to get thumbnail times from youtube APIv3
#thumbnail_time = youtube.get_thumbnail_time(youtube_id)
thumbnail_time = None
zen = Zencoder(zencoder_api_key)
outputs = []
for format_to_create in formats_to_create:
assert format_to_create in output_types(), (format_to_create,
output_types())
outputs += [
fxn(youtube_id, thumbnail_time, base_url)
for fxn in output_types()[format_to_create]
]
job_response = zen.job.create(gcs_url, outputs=outputs)
assert job_response.code == 201, job_response.body
logger.info("Zencoder job created successfully")
def schedule_zencoder_job(self):
zen = Zencoder("7f188a0403a4caac59d8a0080015cae9", api_version = "v2", as_xml = False, test = True)
output = {}
output["url"] = "s3://nandotorres/%s.%s" % (self.file.name.split("/")[-1], self.formato)
output["base_url"] = "s3://nandotorres/"
output["format"] = self.formato
output["public"] = 1
output["notifications"] = [{ "url": ("%s/notify/%s" % (settings.SITE_URL, self.id)) }]
job = zen.job.create("s3://nandotorres/videos/" + self.file.name, output)
return job
def _config_encoding_backend(self):
# Encoding backend
if self.config['ENCODING_BACKEND'] != 'zencoder':
self.log.warning(
'Encoding backend %r not supported, no video encoding possible!',
self.config['ENCODING_BACKEND'])
return
self.log.info('Setting up video encoding backend %r',
self.config['ENCODING_BACKEND'])
from zencoder import Zencoder
self.encoding_service_client = Zencoder(
self.config['ZENCODER_API_KEY'])
def execute(self):
client = Zencoder(API_KEY)
jobContext = self.job.getJobDescription()['output']
uniquePath = WEBHOOK_PATH.replace("{jobid}", str(self.job.getId()))
responseWebhook = WEBHOOK_ORIGIN + uniquePath
response = client.job.create(self.job.getSrc(),
outputs=(jobContext),
options={
"credentials": CREDENTIAL_NAME,
"notifications": [responseWebhook]
})
if response.code == ZENCODER.RESPONSE_SUCCESS.value:
return response.body['id']
else:
return -1
def start_zencoder_job(video_id):
vid = Video.objects.get(video_id=video_id)
logger = start_zencoder_job.get_logger()
logger.info('Uploading %s: %s' % (vid.filename, vid.fp_url))
directory = vid.fp_url.split('/')[-1]
base_dir = DIRECTORY % (directory)
mp4_file = MP4 % (directory)
webm_file = WEBM % (directory)
client = Zencoder(settings.ZENCODER_API_KEY)
dimensions = '700x395'
response = client.job.create(vid.fp_url,
outputs=[{
'size': dimensions,
'base_url': base_dir,
'filename': mp4_file,
'public': True,
'aspect_mode': 'pad'
}, {
'size': dimensions,
'base_url': base_dir,
'filename': webm_file,
'public': True,
'aspect_mode': 'pad'
}, {
"notifications": [{
"url":
settings.ZENCODER_WEBHOOK_URL
}],
"thumbnails": [{
'number': 5,
'size': '700x435',
'public': True,
'label': 'poster',
'base_url': base_dir,
'aspect_mode': 'pad'
}]
}])
vid.job_id = response.body.get('id', 0)
vid.save()
if response.code != 201 or vid.job_id == 0:
logger.info('Error uploading %s: %s' % (vid.filename, vid.fp_url))
def client():
return Zencoder(settings.ZENCODER_API_KEY)
def test_set_api_edge_version(self):
os.environ['ZENCODER_API_KEY'] = 'abcd123'
zc = Zencoder(api_version='edge')
self.assertEquals(zc.base_url, 'https://app.zencoder.com/api/')
def test_set_cert_path(self):
api_key = 'testapikey'
cert = '/path/to/cert.pem'
zc = Zencoder(api_key=api_key, cert=cert)
self.assertEquals(zc.job.requests_params['cert'], cert)
# Algolia search
if 'ALGOLIA_USER' in app.config:
from algoliasearch import algoliasearch
client = algoliasearch.Client(app.config['ALGOLIA_USER'],
app.config['ALGOLIA_API_KEY'])
algolia_index_users = client.init_index(app.config['ALGOLIA_INDEX_USERS'])
algolia_index_nodes = client.init_index(app.config['ALGOLIA_INDEX_NODES'])
else:
algolia_index_users = None
algolia_index_nodes = None
# Encoding backend
if app.config['ENCODING_BACKEND'] == 'zencoder':
encoding_service_client = Zencoder(app.config['ZENCODER_API_KEY'])
else:
encoding_service_client = None
from utils.authentication import validate_token
from utils.authorization import check_permissions
from utils.activities import notification_parse
from modules.projects import before_inserting_projects
from modules.projects import after_inserting_projects
@app.before_request
def validate_token_at_every_request():
validate_token()
def test_set_proxies(self):
api_key = 'testapikey'
proxies = {'https': 'https://10.10.1.10:1080'}
zc = Zencoder(api_key=api_key, proxies=proxies)
self.assertEquals(zc.job.requests_params['proxies'], proxies)
def test_set_verify_false(self):
api_key = 'testapikey'
zc = Zencoder(api_key=api_key, verify=False)
self.assertEquals(zc.job.requests_params['verify'], False)
def test_set_base_url(self):
os.environ['ZENCODER_API_KEY'] = 'abcd123'
zc = Zencoder(base_url='https://localhost:800/foo/')
self.assertEquals(zc.base_url, 'https://localhost:800/foo/')
def test_set_timeout(self):
api_key = 'testapikey'
zc = Zencoder(api_key=api_key, timeout=999)
self.assertEquals(zc.job.requests_params['timeout'], 999)
def check_zencoder_progress(job_id):
client = Zencoder(settings.ZENCODER_API_KEY)
# Get file details.
details_response = client.job.details(job_id)
response_dict = details_response.__dict__
response_body = response_dict.get('body', None)
if not response_body:
return
job = response_body.get('job', None)
if not job:
return
if job:
input_file = job.get('input_media_file', None)
output_files = job.get('output_media_files', list())
thumbnails = job.get('thumbnails', list())
mp4_url = None
webm_url = None
if not input_file:
return
for output in output_files:
url = output.get('url', '')
if url.startswith('http://'):
url = url.replace('http://', 'https://')
if url.endswith('.mp4'):
mp4_url = url
elif url.endswith('.webm'):
webm_url = url
else:
pass
if webm_url is None and mp4_url is None:
return
# Update video attributes.
duration = input_file.get('duration_in_ms', 0)
if duration > 0:
duration = duration / 1000
video = Video.objects.get(job_id=job_id)
video.processing = False
video.duration = duration
video.webm_url = webm_url
video.mp4_url = mp4_url
video.save()
# Save video poster images.
for thumb in thumbnails:
if thumb.get('url', None):
t = Thumbnail()
t.url = thumb.get('url')
t.video = video
if t.url.startswith('http://'):
t.url = t.url.replace('http://', 'https://')
t.save()
# Add UserVideo entry.
user_video = UserVideo()
user_video.user = video.added_by
user_video.video = video
user_video.is_featured = False
user_video.save()
action.send(video.added_by,
verb='added video to library',
action_object=video,
target=user_video)
# Reset Video job id, so we don't receive duplicate uploads.
video.job_id = None
video.save()
def test_default_api_version(self):
os.environ['ZENCODER_API_KEY'] = 'abcd123'
zc = Zencoder()
self.assertEquals(zc.base_url, 'https://app.zencoder.com/api/v2/')
def test_api_key_env_var(self):
""" tests the ZENOCODER_API_KEY environment var """
os.environ['ZENCODER_API_KEY'] = 'abcd123'
zc = Zencoder()
self.assertEquals(zc.api_key, 'abcd123')
def test_api_key(self):
""" initialize zencoder object and test api key """
api_key = 'testapikey'
zc = Zencoder(api_key=api_key)
self.assertEquals(zc.api_key, api_key)
def setUp(self):
self.zen = Zencoder(api_key=TEST_API_KEY)