vim-rana-local/plugin/packages/wakatime/main.py

321 lines
10 KiB
Python
Raw Normal View History

# -*- coding: utf-8 -*-
"""
2015-09-02 15:40:11 +00:00
wakatime.main
2015-03-09 22:27:37 +00:00
~~~~~~~~~~~~~
2017-02-21 00:22:21 +00:00
Module entry point.
:copyright: (c) 2013 Alan Hamlett.
:license: BSD, see LICENSE for more details.
"""
from __future__ import print_function
import base64
import logging
import os
import re
import sys
import traceback
2015-07-04 05:53:46 +00:00
import socket
2016-03-06 20:47:51 +00:00
pwd = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.dirname(pwd))
sys.path.insert(0, os.path.join(pwd, 'packages'))
2014-06-09 20:23:03 +00:00
2015-03-09 22:27:37 +00:00
from .__about__ import __version__
2017-02-21 00:22:21 +00:00
from .arguments import parseArguments
from .compat import u, is_py3
2016-03-06 20:47:51 +00:00
from .constants import (
API_ERROR,
AUTH_ERROR,
SUCCESS,
2016-03-06 22:15:47 +00:00
UNKNOWN_ERROR,
2016-04-28 22:16:08 +00:00
MALFORMED_HEARTBEAT_ERROR,
2016-03-06 20:47:51 +00:00
)
from .logger import setup_logging
2015-05-12 22:02:09 +00:00
from .offlinequeue import Queue
2016-01-11 19:21:18 +00:00
from .packages import requests
from .packages.requests.exceptions import RequestException
2015-06-30 02:31:48 +00:00
from .project import get_project_info
2015-05-12 22:02:09 +00:00
from .session_cache import SessionCache
from .stats import get_file_stats
2017-02-21 00:22:21 +00:00
from .utils import get_user_agent, should_exclude, format_file_path
2014-06-09 20:23:03 +00:00
try:
from .packages import simplejson as json # pragma: nocover
2015-09-29 10:10:32 +00:00
except (ImportError, SyntaxError): # pragma: nocover
import json
2016-04-18 22:24:04 +00:00
from .packages import tzlocal
2014-07-25 09:45:35 +00:00
log = logging.getLogger('WakaTime')
2016-03-06 20:47:51 +00:00
def send_heartbeat(project=None, branch=None, hostname=None, stats={}, key=None,
2016-04-28 22:16:08 +00:00
entity=None, timestamp=None, is_write=None, plugin=None,
2016-03-06 20:47:51 +00:00
offline=None, entity_type='file', hidefilenames=None,
proxy=None, api_url=None, timeout=None, **kwargs):
2015-04-04 18:02:28 +00:00
"""Sends heartbeat as POST request to WakaTime api server.
2016-03-06 20:47:51 +00:00
Returns `SUCCESS` when heartbeat was sent, otherwise returns an
error code constant.
2015-04-04 18:02:28 +00:00
"""
if not api_url:
2016-01-06 21:56:07 +00:00
api_url = 'https://api.wakatime.com/api/v1/heartbeats'
2015-09-29 10:10:32 +00:00
if not timeout:
2016-04-28 22:16:08 +00:00
timeout = 60
2015-04-04 18:02:28 +00:00
log.debug('Sending heartbeat to api at %s' % api_url)
data = {
'time': timestamp,
2015-09-02 15:40:11 +00:00
'entity': entity,
'type': entity_type,
}
2015-09-02 15:40:11 +00:00
if hidefilenames and entity is not None and entity_type == 'file':
2017-02-09 03:21:33 +00:00
for pattern in hidefilenames:
try:
compiled = re.compile(pattern, re.IGNORECASE)
if compiled.search(entity):
extension = u(os.path.splitext(data['entity'])[1])
data['entity'] = u('HIDDEN{0}').format(extension)
break
except re.error as ex:
log.warning(u('Regex error ({msg}) for include pattern: {pattern}').format(
msg=u(ex),
pattern=u(pattern),
))
2013-09-22 23:22:11 +00:00
if stats.get('lines'):
data['lines'] = stats['lines']
if stats.get('language'):
data['language'] = stats['language']
if stats.get('dependencies'):
data['dependencies'] = stats['dependencies']
2015-05-12 22:02:09 +00:00
if stats.get('lineno'):
data['lineno'] = stats['lineno']
if stats.get('cursorpos'):
data['cursorpos'] = stats['cursorpos']
2016-04-28 22:16:08 +00:00
if is_write:
data['is_write'] = is_write
if project:
data['project'] = project
if branch:
data['branch'] = branch
log.debug(data)
# setup api request
2014-09-30 16:23:17 +00:00
request_body = json.dumps(data)
api_key = u(base64.b64encode(str.encode(key) if is_py3 else key))
auth = u('Basic {api_key}').format(api_key=api_key)
headers = {
'User-Agent': get_user_agent(plugin),
'Content-Type': 'application/json',
'Accept': 'application/json',
'Authorization': auth,
}
2015-07-04 05:53:46 +00:00
if hostname:
2016-03-06 22:15:47 +00:00
headers['X-Machine-Name'] = u(hostname).encode('utf-8')
2014-12-01 06:19:45 +00:00
2013-10-01 05:00:41 +00:00
# add Olson timezone to request
try:
tz = tzlocal.get_localzone()
except:
tz = None
2013-10-01 05:00:41 +00:00
if tz:
2016-03-06 22:15:47 +00:00
headers['TimeZone'] = u(tz.zone).encode('utf-8')
2013-10-01 05:00:41 +00:00
2015-05-12 22:02:09 +00:00
session_cache = SessionCache()
session = session_cache.get()
2017-02-21 00:22:21 +00:00
proxies = {}
if proxy:
if '\\' in proxy:
from .packages.requests_ntlm import HttpNtlmAuth
username = proxy.rsplit(':', 1)
password = ''
if len(username) == 2:
password = username[1]
username = username[0]
session.auth = HttpNtlmAuth(username, password, session)
else:
proxies['https'] = proxy
# log time to api
2013-09-07 05:49:47 +00:00
response = None
try:
2015-05-12 22:02:09 +00:00
response = session.post(api_url, data=request_body, headers=headers,
2016-03-06 20:47:51 +00:00
proxies=proxies, timeout=timeout)
except RequestException:
exception_data = {
2014-09-30 16:23:17 +00:00
sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
2013-09-07 05:49:47 +00:00
}
if log.isEnabledFor(logging.DEBUG):
exception_data['traceback'] = traceback.format_exc()
if offline:
queue = Queue()
queue.push(data, json.dumps(stats), plugin)
if log.isEnabledFor(logging.DEBUG):
log.warn(exception_data)
else:
log.error(exception_data)
2016-07-06 21:22:48 +00:00
except: # delete cached session when requests raises unknown exception
exception_data = {
sys.exc_info()[0].__name__: u(sys.exc_info()[1]),
'traceback': traceback.format_exc(),
}
if offline:
queue = Queue()
queue.push(data, json.dumps(stats), plugin)
log.warn(exception_data)
session_cache.delete()
else:
2016-03-06 20:47:51 +00:00
code = response.status_code if response is not None else None
content = response.text if response is not None else None
if code == requests.codes.created or code == requests.codes.accepted:
log.debug({
2016-03-06 20:47:51 +00:00
'response_code': code,
})
2015-05-12 22:02:09 +00:00
session_cache.save(session)
2016-03-06 20:47:51 +00:00
return SUCCESS
if offline:
2016-03-06 20:47:51 +00:00
if code != 400:
2014-12-15 18:05:51 +00:00
queue = Queue()
queue.push(data, json.dumps(stats), plugin)
2016-03-06 20:47:51 +00:00
if code == 401:
log.error({
2016-03-06 20:47:51 +00:00
'response_code': code,
'response_content': content,
})
2016-03-06 20:47:51 +00:00
session_cache.delete()
return AUTH_ERROR
elif log.isEnabledFor(logging.DEBUG):
log.warn({
2016-03-06 20:47:51 +00:00
'response_code': code,
'response_content': content,
})
else:
log.error({
2016-03-06 20:47:51 +00:00
'response_code': code,
'response_content': content,
})
else:
log.error({
2016-03-06 20:47:51 +00:00
'response_code': code,
'response_content': content,
})
2015-05-12 22:02:09 +00:00
session_cache.delete()
2016-03-06 20:47:51 +00:00
return API_ERROR
def sync_offline_heartbeats(args, hostname):
"""Sends all heartbeats which were cached in the offline Queue."""
queue = Queue()
while True:
heartbeat = queue.pop()
if heartbeat is None:
break
status = send_heartbeat(
project=heartbeat['project'],
entity=heartbeat['entity'],
timestamp=heartbeat['time'],
branch=heartbeat['branch'],
hostname=hostname,
stats=json.loads(heartbeat['stats']),
key=args.key,
2016-04-28 22:16:08 +00:00
is_write=heartbeat['is_write'],
2016-03-06 20:47:51 +00:00
plugin=heartbeat['plugin'],
offline=args.offline,
hidefilenames=args.hidefilenames,
entity_type=heartbeat['type'],
proxy=args.proxy,
api_url=args.api_url,
timeout=args.timeout,
)
if status != SUCCESS:
if status == AUTH_ERROR:
return AUTH_ERROR
break
return SUCCESS
2016-04-28 22:16:08 +00:00
def process_heartbeat(args, configs, hostname, heartbeat):
exclude = should_exclude(heartbeat['entity'], args.include, args.exclude)
if exclude is not False:
log.debug(u('Skipping because matches exclude pattern: {pattern}').format(
pattern=u(exclude),
))
return SUCCESS
if heartbeat.get('entity_type') not in ['file', 'domain', 'app']:
heartbeat['entity_type'] = 'file'
2016-09-13 13:56:31 +00:00
if heartbeat['entity_type'] == 'file':
heartbeat['entity'] = format_file_path(heartbeat['entity'])
2016-04-28 22:16:08 +00:00
if heartbeat['entity_type'] != 'file' or os.path.isfile(heartbeat['entity']):
stats = get_file_stats(heartbeat['entity'],
entity_type=heartbeat['entity_type'],
lineno=heartbeat.get('lineno'),
cursorpos=heartbeat.get('cursorpos'),
plugin=args.plugin,
2017-02-21 00:22:21 +00:00
language=heartbeat.get('language'))
2016-04-28 22:16:08 +00:00
project = heartbeat.get('project') or heartbeat.get('alternate_project')
branch = None
if heartbeat['entity_type'] == 'file':
project, branch = get_project_info(configs, heartbeat)
heartbeat['project'] = project
heartbeat['branch'] = branch
heartbeat['stats'] = stats
heartbeat['hostname'] = hostname
heartbeat['timeout'] = args.timeout
heartbeat['key'] = args.key
2016-04-28 23:15:10 +00:00
heartbeat['plugin'] = args.plugin
heartbeat['offline'] = args.offline
heartbeat['hidefilenames'] = args.hidefilenames
heartbeat['proxy'] = args.proxy
heartbeat['api_url'] = args.api_url
2016-04-28 22:16:08 +00:00
return send_heartbeat(**heartbeat)
else:
log.debug('File does not exist; ignoring this heartbeat.')
return SUCCESS
2015-09-08 04:29:53 +00:00
def execute(argv=None):
if argv:
sys.argv = ['wakatime'] + argv
args, configs = parseArguments()
setup_logging(args, __version__)
2015-12-01 20:09:14 +00:00
try:
2016-04-28 22:16:08 +00:00
hostname = args.hostname or socket.gethostname()
heartbeat = vars(args)
retval = process_heartbeat(args, configs, hostname, heartbeat)
if args.extra_heartbeats:
try:
for heartbeat in json.loads(sys.stdin.readline()):
retval = process_heartbeat(args, configs, hostname, heartbeat)
except json.JSONDecodeError:
retval = MALFORMED_HEARTBEAT_ERROR
if retval == SUCCESS:
retval = sync_offline_heartbeats(args, hostname)
return retval
2015-12-01 20:09:14 +00:00
except:
2016-09-02 08:47:21 +00:00
log.traceback(logging.ERROR)
2016-04-28 22:16:08 +00:00
print(traceback.format_exc())
2016-03-06 22:15:47 +00:00
return UNKNOWN_ERROR