#!/usr/bin/env python # -*- coding: utf-8 -*- """ Use Tautulli draw a map connecting Server to Clients based on IP addresses. optional arguments: -h, --help show this help message and exit -m , --map Map location. choices: (NA, EU, World, Geo) (default: NA) -c [], --count [] How many IPs to attempt to check. (default: 2) -u [ ...], --users [ ...] Space separated list of case sensitive names to process. Allowed names are: {List of Users} (default: all) -i [ ...], --ignore [ ...] Space separated list of case sensitive names to process. Allowed names are: {List of Users} (default: None) -f [ ...], --filename [ ...] Filename of map. None will not save. (default: Map_YYYYMMDD-HHMMSS) -j [], --json [] Filename of json file to use. (choices: {List of .json files in current dir}) --headless Run headless. """ from __future__ import print_function from __future__ import unicode_literals from builtins import zip from builtins import str from builtins import range from builtins import object import requests import sys import json import os from collections import OrderedDict import argparse # import numpy as np import time import webbrowser import re # ## EDIT THESE SETTINGS ## TAUTULLI_APIKEY = '' # Your Tautulli API key TAUTULLI_URL = 'http://localhost:8181/' # Your Tautulli URL # Replace LAN IP addresses that start with the LAN_SUBNET with a WAN IP address # to retrieve geolocation data. Leave REPLACEMENT_WAN_IP blank for no replacement. LAN_SUBNET = ('10.10', '127.0.0') REPLACEMENT_WAN_IP = '' # Enter Friendly name for Server ie 'John Smith' SERVER_FRIENDLY = 'Server' # Server location information. Find this information on your own. # If server plot is out of scope add print(geo_lst) after ut.user_id loop ~line 151 to find the error SERVER_LON = '' SERVER_LAT = '' SERVER_CITY = '' SERVER_STATE = '' SERVER_PLATFORM = 'Server' DEFAULT_COLOR = '#A96A1C' # Plex Orange? PLATFORM_COLORS = {'Android': '#a4c639', # Green 'Roku': '#800080', # Purple 'Chromecast': '#ffff00', # Yellow 'Xbox One': '#ffffff', # White 'Chrome': '#ff0000', # Red 'Playstation 4': '#0000ff', # Blue 'iOS': '#8b4513', # Poop brown 'Samsung': '#0c4da2', # Blue 'Windows': DEFAULT_COLOR, 'Xbox 360 App': DEFAULT_COLOR} # title of map title_string = "Location of Plex users based on ISP data" def clean_up_text(title): cleaned = re.sub('\W+', ' ', title) return cleaned class GeoData(object): def __init__(self, data=None): data = data or {} self.continent = data.get('continent', 'N/A') self.country = data.get('country', 'N/A') self.region = clean_up_text(data.get('region', 'N/A')) self.city = clean_up_text(data.get('city', 'N/A')) self.postal_code = data.get('postal_code', 'N/A') self.timezone = data.get('timezone', 'N/A') self.latitude = data.get('latitude', 'N/A') self.longitude = data.get('longitude', 'N/A') self.accuracy = data.get('accuracy', 'N/A') class UserIPs(object): def __init__(self, data=None): d = data or {} self.ip_address = d['ip_address'] self.friendly_name = clean_up_text(d['friendly_name']) self.play_count = d['play_count'] self.platform = d['platform'] def get_users_tables(users='', length=''): # Get the users list from Tautulli if length: payload = {'apikey': TAUTULLI_APIKEY, 'cmd': 'get_users_table', 'length': length} else: payload = {'apikey': TAUTULLI_APIKEY, 'cmd': 'get_users_table'} try: r = requests.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload) response = r.json() res_data = response['response']['data']['data'] if not length and not users: # Return total user count return response['response']['data']['recordsTotal'] else: if users == 'all': return [d['user_id'] for d in res_data] elif users == 'friendly_name': return [d['friendly_name'] for d in res_data] else: return [d['user_id'] for user in users for d in res_data if user == d['friendly_name']] except Exception as e: sys.stderr.write("Tautulli API 'get_users_tables' request failed: {0}.".format(e)) def get_users_ips(user_id, length): # Get the user IP list from Tautulli payload = {'apikey': TAUTULLI_APIKEY, 'cmd': 'get_user_ips', 'user_id': user_id} try: r = requests.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload) response = r.json() res_data = response['response']['data']['data'] return [UserIPs(data=d) for d in res_data] except Exception as e: sys.stderr.write("Tautulli API 'get_users_ips' request failed: {0}.".format(e)) def get_geoip_info(ip_address=''): # Get the geo IP lookup from Tautulli payload = {'apikey': TAUTULLI_APIKEY, 'cmd': 'get_geoip_lookup', 'ip_address': ip_address} try: r = requests.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload) response = r.json() if response['response']['result'] == 'success': data = response['response']['data'] if data.get('error'): raise Exception(data['error']) else: sys.stdout.write("Successfully retrieved geolocation data.") return GeoData(data=data) else: raise Exception(response['response']['message']) except Exception as e: sys.stderr.write("Tautulli API 'get_geoip_lookup' request failed: {0}.".format(e)) pass def add_to_dictlist(d, key, val): if key not in d: d[key] = [val] else: d[key].append(val) for x in d[key]: if (val['region'], val['city']) == (x['region'], x['city']): x['location_count'] += 1 def get_geo_dict(length, users): geo_dict = {SERVER_FRIENDLY: [{'lon': SERVER_LON, 'lat': SERVER_LAT, 'city': SERVER_CITY, 'region': SERVER_STATE, 'ip': REPLACEMENT_WAN_IP, 'play_count': 0, 'platform': SERVER_PLATFORM, 'location_count': 0}]} for i in get_users_tables(users): user_ip = get_users_ips(user_id=i, length=length) city_cnt = 0 for a in user_ip: try: ip = a.ip_address if ip.startswith(LAN_SUBNET) and REPLACEMENT_WAN_IP: ip = REPLACEMENT_WAN_IP g = get_geoip_info(ip_address=ip) add_to_dictlist(geo_dict, a.friendly_name, {'lon': str(g.longitude), 'lat': str(g.latitude), 'city': str(g.city), 'region': str(g.region), 'ip': ip, 'play_count': a.play_count, 'platform': a.platform, 'location_count': city_cnt}) except AttributeError: print('User: {} IP: {} caused error in geo_dict.'.format(a.friendly_name, a.ip_address)) pass except Exception as e: print('Error here: {}'.format(e)) pass return geo_dict def get_geojson_dict(user_locations): locs = [] for username, locations in user_locations.items(): for location in locations: try: locs.append({ "type": "Feature", "properties": { "User": username, "City": location['city'], "State": location['region'], "IP": location['ip'], "Count": location['play_count'] }, "geometry": { "type": "Point", "coordinates": [ float(location['lon']), float(location['lat']) ] } }) locs.append({ "type": "Feature", "properties": { "geodesic": "true", "geodesic_steps": 50, "geodesic_wrap": "true" }, "geometry": { "type": "LineString", "coordinates": [ [float(location['lon']), float(location['lat'])], [float(SERVER_LON), float(SERVER_LAT)], ] } }) except ValueError: pass return { "type": "FeatureCollection", "features": locs } def draw_map(map_type, geo_dict, filename, headless, leg_choice): import matplotlib as mpl if headless: mpl.use("Agg") import matplotlib.pyplot as plt from mpl_toolkits.basemap import Basemap # ## Map stuff ## plt.figure(figsize=(16, 9), dpi=100, frameon=False) lon_r = 0 lon_l = 0 if map_type == 'NA': m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-54, urcrnrlat=55, projection='lcc', resolution='l', lat_1=32, lat_2=45, lon_0=-95) lon_r = 66.0 lon_l = -124.0 elif map_type == 'EU': m = Basemap(llcrnrlon=-15., llcrnrlat=20, urcrnrlon=75., urcrnrlat=70, projection='lcc', resolution='l', lat_1=30, lat_2=60, lon_0=35.) lon_r = 50.83 lon_l = -69.03 elif map_type == 'World': m = Basemap(projection='robin', lat_0=0, lon_0=-100, resolution='l', area_thresh=100000.0) # m.drawmeridians(np.arange(0, 360, 30)) # m.drawparallels(np.arange(-90, 90, 30)) lon_r = 180 lon_l = -180.0 # remove line in legend mpl.rcParams['legend.handlelength'] = 0 m.drawmapboundary(fill_color='#1F1F1F') m.drawcoastlines() m.drawstates() m.drawcountries() m.drawlsmask(land_color='#3C3C3C', ocean_color='#1F1F1F') for key, values in geo_dict.items(): # add Accuracy as plot/marker size, change play count to del_s value. for data in values: if key == SERVER_FRIENDLY: color = '#FFAC05' marker = '*' markersize = 10 zord = 3 alph = 1 else: if data['platform'] in PLATFORM_COLORS: color = PLATFORM_COLORS[data['platform']] else: color = DEFAULT_COLOR print('Platform: {} is missing from PLATFORM_COLORS. Using DEFAULT_COLOR.'.format(data['platform'])) marker = '.' if data['play_count'] >= 100: markersize = (data['play_count'] * .1) elif data['play_count'] <= 2: markersize = 2 else: markersize = 2 zord = 2 alph = 0.4 px, py = m(float(data['lon']), float(data['lat'])) x, y = m([float(data['lon']), float(SERVER_LON)], [float(data['lat']), float(SERVER_LAT)]) legend = 'Location: {}, {}, User: {}\nPlatform: {}, IP: {}, Play Count: {}'.format( data['city'], data['region'], key, data['platform'], data['ip'], data['play_count']) # Keeping lines inside the Location. Plots outside Location will still be in legend if float(data['lon']) != float(SERVER_LON) and float(data['lat']) != float(SERVER_LAT) and \ lon_l < float(data['lon']) < lon_r: # Drawing lines from Server location to client location if data['location_count'] > 1: lines = m.plot(x, y, marker=marker, color=color, markersize=0, label=legend, alpha=.6, zorder=zord, linewidth=2) # Adding dash sequence to 2nd, 3rd, etc lines from same city,state for line in lines: line.set_solid_capstyle('round') dashes = [x * data['location_count'] for x in [5, 8, 5, 8]] line.set_dashes(dashes) else: m.plot(x, y, marker=marker, color=color, markersize=0, label=legend, alpha=.4, zorder=zord, linewidth=2) m.plot(px, py, marker=marker, color=color, markersize=markersize, label=legend, alpha=alph, zorder=zord) if leg_choice: handles, labels = plt.gca().get_legend_handles_labels() idx = labels.index('Location: {}, {}, User: {}\nPlatform: {}, IP: {}, Play Count: {}'. format(SERVER_CITY, SERVER_STATE, SERVER_FRIENDLY, SERVER_PLATFORM, REPLACEMENT_WAN_IP, 0)) labels = labels[idx:] + labels[:idx] handles = handles[idx:] + handles[:idx] by_label = OrderedDict(list(zip(labels, handles))) leg = plt.legend(list(by_label.values()), list(by_label.keys()), fancybox=True, fontsize='x-small', numpoints=1, title="Legend", labelspacing=1., borderpad=1.5, handletextpad=2.) if leg: lleng = len(leg.legendHandles) for i in range(1, lleng): leg.legendHandles[i]._legmarker.set_markersize(10) leg.legendHandles[i]._legmarker.set_alpha(1) leg.get_title().set_color('#7B777C') leg.draggable() leg.get_frame().set_facecolor('#2C2C2C') for text in leg.get_texts(): plt.setp(text, color='#A5A5A7') plt.title(title_string) if filename: plt.savefig('{}.png'.format(filename)) print('Image saved as: {}.png'.format(filename)) if not headless: mng = plt.get_current_fig_manager() mng.window.state('zoomed') plt.show() if __name__ == '__main__': timestr = time.strftime("%Y%m%d-%H%M%S") user_count = get_users_tables() user_lst = sorted(get_users_tables('friendly_name', user_count)) json_check = sorted([f for f in os.listdir('.') if os.path.isfile(f) and f.endswith(".json")], key=os.path.getmtime) parser = argparse.ArgumentParser(description="Use PlexPy to draw map of user locations base on IP address.", formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('-m', '--map', default='NA', choices=['NA', 'EU', 'World', 'Geo'], metavar='', help='Map location. choices: (%(choices)s) \n(default: %(default)s)') parser.add_argument('-c', '--count', nargs='?', type=int, default=2, metavar='', help='How many IPs to attempt to check. \n(default: %(default)s)') parser.add_argument('-u', '--users', nargs='+', type=str, default='all', choices=user_lst, metavar='', help='Space separated list of case sensitive names to process. Allowed names are: \n' '%(choices)s \n(default: %(default)s)') parser.add_argument('-i', '--ignore', nargs='+', type=str, default=None, choices=user_lst, metavar='', help='Space separated list of case sensitive names to process. Allowed names are: \n' '%(choices)s \n(default: %(default)s)') parser.add_argument('-f', '--filename', nargs='+', type=str, default='Map_{}'.format(timestr), metavar='', help='Filename of map. None will not save. \n(default: %(default)s)') parser.add_argument('-j', '--json', nargs='?', type=str, choices=json_check, metavar='', help='Filename of json file to use. \n(choices: %(choices)s)') parser.add_argument('--headless', action='store_true', help='Run headless.') parser.add_argument('--legend', dest='legend', action='store_true', help='Toggle on legend.') parser.add_argument('--no_legend', dest='legend', action='store_false', help='Toggle off legend.') parser.set_defaults(legend=True) opts = parser.parse_args() if opts.json: if opts.filename == ['None']: filename = None else: filename = '{}'.format(''.join(opts.filename)) print('Using existing .json file to map.') with open(''.join(opts.json)) as json_data: geo_json = json.load(json_data) else: # print(opts) if opts.ignore and opts.users == 'all': users = [x for x in user_lst if x not in opts.ignore] else: users = opts.users if opts.filename == ['None']: filename = None json_file = '{}.json'.format(timestr) else: filename = '{}'.format(''.join(opts.filename)) json_file = '{}.json'.format(''.join(opts.filename)) geo_json = get_geo_dict(opts.count, users) with open(json_file, 'w') as fp: json.dump(geo_json, fp, indent=4, sort_keys=True) if opts.map == 'Geo': geojson = get_geojson_dict(geo_json) print("\n") r = requests.post("https://api.github.com/gists", json={ "description": title_string, "files": { '{}.geojson'.format(filename): { "content": json.dumps(geojson, indent=4) } } }, headers={ 'Content-Type': 'application/json' }) print(r.json()['html_url']) if not opts.headless: webbrowser.open(r.json()['html_url']) else: draw_map(opts.map, geo_json, filename, opts.headless, opts.legend)