def snap_screenshots(snap_id, session, data=None, files=None):
method = None
files_array = None
headers = get_authorization_header(session)
headers['Accept'] = 'application/json'
if data:
method = 'PUT'
files_array = []
if files:
for f in files:
files_array.append(
(f.filename, (f.filename, f.stream, f.mimetype)))
else:
# API requires a multipart request, but we have no files to push
# https://github.com/requests/requests/issues/1081
files_array = {'info': ('', data['info'])}
data = None
screenshot_response = cache.get(
SCREENSHOTS_QUERY_URL.format(snap_id=snap_id),
headers=headers,
data=data,
method=method,
files=files_array)
if authentication.is_macaroon_expired(screenshot_response.headers):
raise MacaroonRefreshRequired()
return screenshot_response.json()
def post_agreement(agreed):
headers = get_authorization_header()
json = {'latest_tos_accepted': agreed}
agreement_response = cache.get(AGREEMENT_URL, headers, json)
return agreement_response.json()
def get_snap_info(snap_name, session):
response = cache.get(SNAP_INFO_URL.format(snap_name=snap_name),
headers=get_authorization_header(session))
if authentication.is_macaroon_expired(response.headers):
raise MacaroonRefreshRequired()
return process_response(response)
def get_snap_status(snap_id, session):
status_response = cache.get(STATUS_QUERY_URL.format(snap_id=snap_id),
headers=get_authorization_header(session))
if authentication.is_macaroon_expired(status_response.headers):
raise MacaroonRefreshRequired()
return status_response.json()
def get_snap_info(snap_name):
response = cache.get(SNAP_INFO_URL.format(snap_name=snap_name),
headers=get_authorization_header())
if response.status_code == 404:
message = 'Snap not found: {snap_name}'.format(**locals())
flask.abort(404, message)
return response.json()
def get_agreement(session):
headers = get_authorization_header(session)
agreement_response = cache.get(AGREEMENT_URL, headers)
if authentication.is_macaroon_expired(agreement_response.headers):
raise MacaroonRefreshRequired()
return agreement_response.json()
def snap_metadata(snap_id, json=None):
method = "PUT" if json is not None else None
metadata_response = cache.get(METADATA_QUERY_URL.format(snap_id=snap_id),
headers=get_authorization_header(),
json=json,
method=method)
return metadata_response.json()
def get_publisher_metrics(json):
authed_metrics_headers = PUB_METRICS_QUERY_HEADERS.copy()
auth_header = get_authorization_header()['Authorization']
authed_metrics_headers['Authorization'] = auth_header
metrics_response = cache.get(SNAP_PUB_METRICS_URL,
headers=authed_metrics_headers,
json=json)
return metrics_response.json()
def post_agreement(session, agreed):
headers = get_authorization_header(session)
json = {'latest_tos_accepted': agreed}
agreement_response = cache.get(AGREEMENT_URL, headers, json)
if authentication.is_macaroon_expired(agreement_response.headers):
raise MacaroonRefreshRequired()
return agreement_response.json()
def snap_metadata(snap_id, session, json=None):
method = "PUT" if json is not None else None
metadata_response = cache.get(METADATA_QUERY_URL.format(snap_id=snap_id),
headers=get_authorization_header(session),
json=json,
method=method)
if authentication.is_macaroon_expired(metadata_response.headers):
raise MacaroonRefreshRequired()
return metadata_response.json()
def get_publisher_metrics(session, json):
authed_metrics_headers = PUB_METRICS_QUERY_HEADERS.copy()
auth_header = get_authorization_header(session)['Authorization']
authed_metrics_headers['Authorization'] = auth_header
metrics_response = cache.get(SNAP_PUB_METRICS_URL,
headers=authed_metrics_headers,
json=json)
if authentication.is_macaroon_expired(metrics_response.headers):
raise MacaroonRefreshRequired()
return metrics_response.json()
def get_snap_details(snap_name):
details_response = cache.get(SNAP_DETAILS_URL.format(snap_name=snap_name),
headers=DETAILS_QUERY_HEADERS)
if details_response.status_code >= 400:
message = ('Failed to get snap details for {snap_name}'.format(
**locals()))
if details_response.status_code == 404:
message = 'Snap not found: {snap_name}'.format(**locals())
flask.abort(details_response.status_code, message)
return details_response.json()
def get_cache(reqdata, req_id, debugging):
log.info("[#%s] get_cache@modules/skill.py: New Request" % req_id)
# 사용자 ID 가져오고 검증
uid = json.loads(reqdata)["userRequest"]["user"]["id"]
if user.auth_admin(uid, req_id, debugging):
cache_list = cache.get(req_id, debugging)
if cache_list == "":
log.info("[#%s] get_cache@modules/skill.py: No Cache" % req_id)
cache_list = "\n캐시가 없습니다."
msg = "캐시 목록:" + cache_list
else:
log.info("[#%s] get_cache@modules/skill.py: Non-Authorized User" %
req_id)
msg = "사용자 인증에 실패하였습니다.\n당신의 UID는 %s 입니다." % uid
return skill(msg)
def post_username(session, username):
headers = get_authorization_header(session)
json = {'short_namespace': username}
username_response = cache.get(url=ACCOUNT_URL,
headers=headers,
json=json,
method='PATCH')
if authentication.is_macaroon_expired(username_response.headers):
raise MacaroonRefreshRequired()
if username_response.status_code == 204:
return {}
else:
return username_response.json()
def get_account(session):
authorization = authentication.get_authorization_header(
session['macaroon_root'], session['macaroon_discharge'])
headers = {
'X-Ubuntu-Series': '16',
'X-Ubuntu-Architecture': 'amd64',
'Authorization': authorization
}
response = cache.get(url=ACCOUNT_URL, method='GET', headers=headers)
if authentication.is_macaroon_expired(response.headers):
raise MacaroonRefreshRequired()
return response.json()
def resolve(url):
try:
log("Resolver called with url: " + url)
resolved=resolve_it(url)
if resolved==None:
#semi-cached resolving
url=cache.get(find_link,3600*3,url)
resolved=url
url=resolve_it(url)
if url!=None:
resolved=url
log("Resolved url: " + resolved)
return resolved
except:
log("Failed to find link.")
return url
def resolve(url, cache_timeout=3, html=None, title='Video'):
#try:
log("Resolver called with url: " + url)
resolved=None
if html==None:
resolved=resolve_it(url,title=title)
if resolved==None:
if html==None and cache_timeout!=0:
#semi-cached resolving
url=cache.get(find_link,cache_timeout,url)
else:
url = find_link(url,html=html)
resolved=url
url=resolve_it(url,title=title)
if url!=None:
resolved=url
log("Resolved url: " + resolved)
return resolved
def get_account():
authorization = authentication.get_authorization_header(
flask.session['macaroon_root'], flask.session['macaroon_discharge'])
headers = {
'X-Ubuntu-Series': '16',
'X-Ubuntu-Architecture': 'amd64',
'Authorization': authorization
}
response = cache.get(url=ACCOUNT_URL, method='GET', headers=headers)
verified_response = verify_response(response, ACCOUNT_URL, '/account',
'/login')
if verified_response is not None:
return {'redirect': verified_response}
return response.json()
def resolve(url, cache_timeout=3, html=None):
try:
log("Resolver called with url: " + url)
resolved = None
if html == None:
resolved = resolve_it(url)
if resolved == None:
if html == None:
#semi-cached resolving
url = cache.get(find_link, cache_timeout, url)
else:
url = find_link(url, html=html)
resolved = url
url = resolve_it(url)
if url != None:
resolved = url
log("Resolved url: " + resolved)
return resolved
except:
log("Failed to find link.")
return url
def resolve(url, cache_timeout=3, html=None):
try:
log("Resolver called with url: " + url)
resolved=None
if html==None:
resolved=resolve_it(url)
if resolved==None:
if html==None:
#semi-cached resolving
url=cache.get(find_link,cache_timeout,url)
else:
url = find_link(url,html=html)
resolved=url
url=resolve_it(url)
if url!=None:
resolved=url
log("Resolved url: " + resolved)
return resolved
except:
log("Failed to find link.")
return url
def snap_screenshots(snap_id, data=None, files=None):
method = None
files_array = None
headers = get_authorization_header()
headers['Accept'] = 'application/json'
if data is not None:
method = 'PUT'
files_array = []
if files is not None:
for f in files:
files_array.append(
(f.filename, (f.filename, f.stream, f.mimetype)))
screenshot_response = cache.get(
SCREENSHOTS_QUERY_URL.format(snap_id=snap_id),
headers=headers,
data=data,
method=method,
files=files_array)
return screenshot_response.json()
def resolve(url, cache_timeout=3, html=None, title='Video', icon='x'):
try:
log("Resolver called with url: " + url)
resolved = None
if html == None:
resolved = resolve_it(url, title=title)
if resolved == None:
if html == None and cache_timeout != 0:
#semi-cached resolving
url = cache.get(find_link, cache_timeout, url)
else:
url = find_link(url, html=html)
resolved = url
url = resolve_it(url, title=title, icon=icon)
if url != None:
resolved = url
log("Resolved url: " + resolved)
return resolved
except:
log("Failed to find link.")
return url
def get_promoted_snaps():
promoted_response = cache.get(PROMOTED_QUERY_URL,
headers=PROMOTED_QUERY_HEADERS)
return normalize_searched_snaps(promoted_response.json())
def get_agreement():
headers = get_authorization_header()
agreement_response = cache.get(AGREEMENT_URL, headers)
return agreement_response.json()
def get_featured_snaps():
featured_response = cache.get(FEATURE_SNAPS_URL,
headers=SEARCH_QUERY_HEADERS)
return process_response(featured_response)
def get_snap_status(snap_id):
status_response = cache.get(STATUS_QUERY_URL.format(snap_id=snap_id),
headers=get_authorization_header())
return status_response.json()
def get_promoted_snaps():
promoted_response = cache.get(PROMOTED_QUERY_URL,
headers=PROMOTED_QUERY_HEADERS)
return process_response(promoted_response)
def get_searched_snaps(snap_searched, size, page):
searched_response = cache.get(SNAP_SEARCH_URL.format(
snap_name=snap_searched, size=size, page=page),
headers=SEARCH_QUERY_HEADERS)
return process_response(searched_response)
def get_snap_details(snap_name):
details_response = cache.get(SNAP_DETAILS_URL.format(snap_name=snap_name),
headers=DETAILS_QUERY_HEADERS)
return process_response(details_response)
def get_public_metrics(snap_name, json):
metrics_response = cache.get(SNAP_METRICS_URL.format(snap_name=snap_name),
headers=METRICS_QUERY_HEADERS,
json=json)
return process_response(metrics_response)
def get_featured_snaps():
featured_response = cache.get(FEATURE_SNAPS_URL,
headers=SEARCH_QUERY_HEADERS)
return normalize_searched_snaps(featured_response.json())
