bashhub 3.0.2__py3-none-any.whl

bashhub/bashhub.py

@@ -0,0 +1,240 @@
+#!/usr/bin/python
+from time import *
+import click
+import traceback
+import dateutil.parser
+import sys
+import os
+import io
+
+from .model import CommandForm
+from . import rest_client
+from . import bashhub_setup
+from . import bashhub_globals
+from .bashhub_globals import BH_FILTER, BH_HOME, BH_SAVE_COMMANDS
+from .bashhub_globals import write_to_config_file
+from .version import version_str
+import shutil
+import requests
+import subprocess
+from . import shell_utils
+import re
+from .view.status import *
+
+
+
+def print_version(ctx, param, value):
+    if not value or ctx.resilient_parsing:
+        return
+    click.echo(version_str)
+    ctx.exit()
+
+
+CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.option('-V',
+              '--version',
+              default=False,
+              is_flag=True,
+              callback=print_version,
+              help='Display version',
+              expose_value=False,
+              is_eager=True)
+def bashhub():
+    """Bashhub command line client"""
+    pass
+
+
+@bashhub.command()
+def version():
+    """Display version"""
+    click.echo(version_str)
+
+
+@bashhub.command()
+@click.option("-g",
+              "--global",
+              "is_global",
+              default=False,
+              is_flag=True,
+              help="Turn off saving commands for all sessions.")
+def off(is_global):
+    """Turn off saving commands to Bashhub. Applies for this current session."""
+    if is_global:
+        write_to_config_file('save_commands', 'False')
+    else:
+        f = io.open(BH_HOME + '/script.bh', 'w+', encoding='utf-8')
+        print(str("export BH_SAVE_COMMANDS='False'"), file=f)
+
+
+@bashhub.command()
+@click.option('-l',
+              "--local",
+              help="Turn on saving commands for only this session.",
+              is_flag=True)
+def on(local):
+    """Turn on saving commands to Bashhub. Applies globally."""
+    f = io.open(BH_HOME + '/script.bh', 'w+', encoding='utf-8')
+
+    if local:
+        print(str("export BH_SAVE_COMMANDS='True'"), file=f)
+    else:
+        print(str("unset BH_SAVE_COMMANDS"), file=f)
+        write_to_config_file('save_commands', 'True')
+
+
+@bashhub.command()
+@click.argument('command', type=str)
+@click.argument('path', type=click.Path(exists=True))
+@click.argument('pid', type=int)
+@click.argument('process_start_time', type=int)
+@click.argument('exit_status', type=int)
+def save(command, path, pid, process_start_time, exit_status):
+    """Save a command to Bashhub"""
+    pid_start_time = unix_time_to_epoc_millis(process_start_time)
+    command = command.strip()
+
+    # Check if we have commands saving turned on
+    if not bashhub_globals.BH_SAVE_COMMANDS:
+        return
+
+    # Check if we should ignore this command.
+    if "#ignore" in command:
+        return
+
+    # Check if we should filter this command.
+    bh_filter = bashhub_globals.BH_FILTER
+    if bh_filter and re.findall(bh_filter, command):
+        return
+
+    # Check that we have an auth token.
+    if bashhub_globals.BH_AUTH() == "":
+        print("No auth token found. Run 'bashhub setup' to login.")
+        return
+
+    command = CommandForm(command, path, exit_status, pid, pid_start_time)
+    rest_client.save_command(command)
+
+
+@bashhub.command()
+def setup():
+    """Run Bashhub user and system setup"""
+    bashhub_setup.main()
+
+
+@bashhub.command()
+def status():
+    """Stats for this session and user"""
+    # Get our user and session information from our context
+    (ppid, start_time) = shell_utils.get_session_information()
+    status_view = rest_client.get_status_view(ppid, start_time)
+    if status_view:
+        click.echo(build_status_view(status_view))
+
+
+@bashhub.command()
+@click.pass_context
+def help(ctx):
+    """Show this message and exit"""
+    click.echo(ctx.parent.get_help())
+
+# Dynamic help text containing the BH_FILTER variable.
+filtered_text = "BH_FILTER={0}".format(
+    BH_FILTER) if BH_FILTER else "BH_FILTER \
+is unset."
+
+filter_help_text = """Check if a command is filtered from bashhub. Filtering
+is configured via a regex exported as BH_FILTER.
+\n
+{0}""".format(filtered_text)
+
+
+@bashhub.command(help=filter_help_text)
+@click.argument('command', type=str)
+@click.option('-r',
+              '--regex',
+              default=BH_FILTER,
+              help='Regex to filter against')
+def filter(command, regex):
+
+    # Check if the regex we receive is valid
+    if not bashhub_globals.is_valid_regex(regex):
+        click.secho("Regex {0} is invalid".format(regex), fg='red')
+        return
+
+    v = re.findall(regex, command)
+    click.echo(filtered_text)
+    if v and regex:
+        matched = [str(s) for s in set(v)]
+        output = click.style("{0} \nIs Filtered. Matched ".format(command),
+                             fg='yellow') + click.style(
+                                 str(matched), fg='red')
+        click.echo(output)
+    else:
+        click.echo("{0} \nIs Unfiltered".format(command))
+
+
+@bashhub.command()
+@click.argument('version', type=str, default='')
+def update(version):
+    """Update your Bashhub installation"""
+
+    if version != '':
+        github = "https://github.com/rcaloras/bashhub-client/archive/{0}.tar.gz".format(
+            version)
+        response = requests.get(github)
+        if response.status_code != 200:
+            click.echo("Invalid version number {0}".format(version))
+            sys.exit(1)
+
+    query_param = '?version={0}'.format(version) if version else ''
+    url = 'https://bashhub.com/setup' + query_param
+    response = requests.get(url, stream=True)
+    filename = 'update-bashhub.sh'
+    with open(filename, 'wb') as out_file:
+        shutil.copyfileobj(response.raw, out_file)
+
+    subprocess.call(["bash", "-e", filename, version])
+    os.remove(filename)
+
+
+@bashhub.group()
+def util():
+    """Misc utils used by Bashhub"""
+    pass
+
+
+@util.command()
+def update_system_info():
+    """Updates system info for Bashhub"""
+    result = bashhub_setup.update_system_info()
+    # Exit code based on if our update call was successful
+    sys.exit(0) if result != None else sys.exit(1)
+
+
+@util.command()
+@click.argument('date_string', type=str)
+def parsedate(date_string):
+    """date string to seconds since the unix epoch"""
+    try:
+        date = dateutil.parser.parse(date_string)
+        unix_time = int(mktime(date.timetuple()))
+        click.echo(unix_time)
+    except Exception as e:
+        # Should really log an error here
+        click.echo(0)
+
+
+def unix_time_to_epoc_millis(unix_time):
+    return int(unix_time) * 1000
+
+
+def main():
+    try:
+        bashhub()
+    except Exception as e:
+        formatted = traceback.format_exc(e)
+        click.echo("Oops, looks like an exception occured: " + str(e))
+        sys.exit(1)

bashhub/bashhub_globals.py

@@ -0,0 +1,83 @@
+"""
+This file should be used for declaring any global variables that need to be
+pulled in from environment variables or are just used across multiple files.
+"""
+
+import os
+import re
+import time
+import stat
+
+import configparser
+from configparser import NoSectionError, NoOptionError
+
+# Current time in milleseconds to use across app.
+current_milli_time = lambda: int(round(time.time() * 1000))
+
+BH_HOME = '~/.bashhub' if 'HOME' not in list(os.environ.keys()) \
+        else os.environ['HOME'] + '/.bashhub'
+
+
+def write_to_config_file(section, value):
+    exists = os.path.exists(BH_HOME)
+    file_path = BH_HOME + '/config'
+    permissions = stat.S_IRUSR | stat.S_IWUSR
+    if exists:
+        config = configparser.ConfigParser()
+        config.read(BH_HOME + '/config')
+        # Add our section if it doesn't exist
+        if not config.has_section("bashhub"):
+            config.add_section("bashhub")
+
+        config.set("bashhub", section, value)
+        with open(file_path, 'w') as config_file:
+            config.write(config_file)
+            os.chmod(file_path, permissions)
+        return True
+    else:
+        print("Couldn't find bashhub home directory. Sorry.")
+        return False
+
+
+def get_from_config(key, default=''):
+    try:
+        config = configparser.ConfigParser()
+        config.read(BH_HOME + '/config')
+        return config.get('bashhub', key)
+    except NoSectionError as error:
+        return default
+    except NoOptionError as error:
+        return default
+
+# Optional environment variable to configure for development
+# export BH_URL='http://localhost:9000'
+BH_URL = os.getenv('BH_URL', get_from_config('url', 'https://bashhub.com'))
+
+BH_SAVE_COMMANDS = os.getenv('BH_SAVE_COMMANDS', \
+    get_from_config('save_commands')).lower() in ('true', 'yes', 't', 'on', '')
+
+BH_SYSTEM_NAME = get_from_config("system_name")
+
+# Check if debug mode is enabled
+BH_DEBUG = os.getenv('BH_DEBUG', get_from_config("debug"))
+
+
+# Get our token from the environment if one is present
+# otherwise retrieve it from our config. Needs to
+# be a function since we may change our token during setup
+def BH_AUTH():
+    return os.getenv('BH_ACCESS_TOKEN', get_from_config("access_token"))
+
+
+def is_valid_regex(regex):
+    try:
+        re.compile(regex)
+        return True
+    except re.error:
+        return False
+
+def get_bh_filter():
+    filter = os.getenv('BH_FILTER', get_from_config('filter'))
+    return filter if is_valid_regex(filter) else '__invalid__'
+
+BH_FILTER =  get_bh_filter()

bashhub/bashhub_setup.py

@@ -0,0 +1,237 @@
+#!/usr/bin/python
+from time import *
+import jsonpickle
+import json
+import sys
+import requests
+import getpass
+import traceback
+import uuid
+import stat
+import socket
+from . import rest_client
+from .version import __version__
+from .model import *
+from .bashhub_globals import *
+import requests
+from requests import ConnectionError
+from requests import HTTPError
+import collections
+import configparser
+
+
+def query_yes_no(question, default="yes"):
+    """Ask a yes/no question via input() and return their answer.
+
+    "question" is a string that is presented to the user.
+    "default" is the presumed answer if the user just hits <Enter>.
+        It must be "yes" (the default), "no" or None (meaning
+        an answer is required of the user).
+
+    The "answer" return value is one of "yes" or "no".
+    """
+    valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
+    if default == None:
+        prompt = " [y/n] "
+    elif default == "yes":
+        prompt = " [Y/n] "
+    elif default == "no":
+        prompt = " [y/N] "
+    else:
+        raise ValueError("invalid default answer: '%s'" % default)
+
+    while True:
+        sys.stdout.write(question + prompt)
+        choice = input().lower()
+        if default is not None and choice == '':
+            return valid[default]
+        elif choice in valid:
+            return valid[choice]
+        else:
+            sys.stdout.write("Please respond with 'yes' or 'no' "
+                             "(or 'y' or 'n').\n")
+
+
+def get_new_user_information():
+    email = input("What's your email? ")
+    username = input("What username would you like? ")
+    password = getpass.getpass("What password? ")
+    print("\nEmail: " + email + " Username: " + username)
+    all_good = query_yes_no("Are these correct?")
+
+    if all_good:
+        return RegisterUser(email, username, password)
+    else:
+        return get_new_user_information()
+
+
+def get_user_information_and_login(username=None, password=None, attempts=0):
+    if attempts == 4:
+        print("Too many bad attempts.")
+        return None
+
+    # Only collect user information if we don't already have it
+    # i.e. if we didn't just register a new user.
+    if username == None and password == None:
+        print("Please enter your bashhub credentials")
+        username = input("Username: ")
+        password = getpass.getpass("Password: ")
+
+    # login once we have all of our information
+    access_token = rest_client.login_user(LoginForm(username, password))
+
+    # Package our result to include our credentials to later login our system.
+    if access_token:
+        result = (username, password, access_token)
+    else:
+        result = get_user_information_and_login(attempts=attempts + 1) or (
+            None, None, None)
+
+    return result
+
+
+def get_mac_address():
+    """Get the mac address for our system as a fingerprint. If we can't
+    get the mac, use the hash of our hostname as a subtitute"""
+
+    mac = uuid.getnode()
+    # check if getnode fails
+    if (mac >> 40) & 1:
+        hostname = socket.gethostname()
+        print("warning: cannot find MAC. Using hostname (%s) to identify system" % hostname)
+        mac = hostname
+    else:
+        mac = str(mac)
+    return mac
+
+
+# Update our hostname incase it changed.
+def update_system_info():
+    mac = get_mac_address()
+    hostname = socket.gethostname()
+    patch = SystemPatch(hostname=hostname, client_version=__version__)
+    return rest_client.patch_system(patch, mac)
+
+
+def handle_system_information(username, password, attempts=0):
+
+    mac = get_mac_address()
+    system = rest_client.get_system_information(mac)
+    system_name = None
+    # Register a new System if this one isn't recognized
+    if system is None:
+        hostname = socket.gethostname()
+        name_input = input("What do you want to call this system? " +
+                               "For example Home, File Server, ect. [%s]: " %
+                               hostname)
+
+        name = name_input or hostname
+        system_name = rest_client.register_system(RegisterSystem(
+            name, mac, hostname, __version__))
+        if system_name:
+            print("Registered a new system " + name)
+        else:
+            if attempts < 3:
+                print("Looks like registering your system failed. Lets retry.")
+                return handle_system_information(username, password, attempts + 1)
+            else:
+                return (None, None)
+
+    # Login with this new system
+    access_token = rest_client.login_user(LoginForm(username, password, mac))
+
+    if access_token is None:
+        print("Failed to login with system.")
+        return (None, None)
+
+    # If this system is already registered
+    if system is not None:
+        system_name = system.name
+        print("Welcome back! Looks like this box is already registered as " +
+              system.name + ".")
+
+    return (access_token, system_name)
+
+
+def main():
+    try:
+
+        ascii_art = r"""
+          ____            _     _           _
+         |  _ \          | |   | |         | |
+         | |_) | __ _ ___| |__ | |__  _   _| |__   ___ ___  _ __ ___
+         |  _ < / _` / __| '_ \| '_ \| | | | '_ \ / __/ _ \| '_ ` _  \
+         | |_) | (_| \__ \ | | | | | | |_| | |_) | (_| (_) | | | | | |
+         |____/ \__,_|___/_| |_|_| |_|\__,_|_.__(_)___\___/|_| |_| |_|
+
+        """
+
+        print(ascii_art)
+        print("Welcome to bashhub setup!")
+        is_new_user = query_yes_no("Are you a new user?")
+
+        # Initialize variaous Credentials for logging in.
+        username = None
+        password = None
+        access_token = None
+
+        # If this is a new user walk them through the registration flow
+        if is_new_user:
+            register_user = get_new_user_information()
+            register_result = rest_client.register_user(register_user)
+            if register_result:
+                print("Registered new user {0}\n".format(
+                    register_user.username))
+                # Set our credentials to login later
+                username = register_user.username
+                password = register_user.password
+            else:
+                print("Sorry, registering a new user failed.")
+                print("You can rerun setup using 'bashhub setup' in a new "
+                      "terminal window.\n")
+                sys.exit(0)
+
+        (username, password, access_token) = get_user_information_and_login(
+            username, password)
+        if access_token == None:
+            print("\nSorry looks like logging in failed.")
+            print("If you forgot your password please reset it. "
+                  "https://bashhub.com/password-reset")
+            print("You can rerun setup using 'bashhub setup' in a new "
+                  "terminal window.\n")
+            sys.exit(0)
+
+        # write out our user scoped access token
+        config_write_result = write_to_config_file("access_token",
+                                                   access_token)
+        if not config_write_result:
+            print("Writing your config file failed.")
+            sys.exit(1)
+
+        (access_token, system_name) = handle_system_information(username,
+                                                                password)
+
+        if access_token == None:
+            print("Sorry looks like getting your info failed.\
+                    Exiting...")
+            sys.exit(0)
+
+        # write out our system scoped token and the system name
+        write_to_config_file("access_token", access_token)
+        write_to_config_file("system_name", system_name)
+        update_system_info()
+
+        sys.exit(0)
+
+    except Exception as err:
+        sys.stderr.write('Setup Error:\n%s\n' % str(err))
+        traceback.print_exc()
+        sys.exit(1)
+    except KeyboardInterrupt:
+        # To allow Ctrl+C (^C). Print a new line to drop the prompt.
+        print("")
+        sys.exit()
+
+
+if __name__ == "__main__":
+    main()

bashhub/bh.py

@@ -0,0 +1,125 @@
+#!/usr/bin/python
+
+import click
+import sys
+import io
+import os
+import traceback
+import datetime
+from .bashhub_globals import *
+from . import rest_client
+from .i_search import InteractiveSearch
+from .version import version_str
+
+@click.command()
+@click.argument('query', type=str, default='')
+@click.option('-n', '--number', default=None, help='Limit the number of previous commands. Default is 100.', type=int)
+@click.option("-ses",
+             "--session",
+             help="Filter by specific session id. Default is None.",
+             default=None,
+             type=str)
+@click.option("-d",
+             "--directory",
+             help="Search for commands within this directory.",
+             default=False,
+             is_flag=True)
+@click.option("-sys",
+             "--system",
+             help="Search for commands created on this system.",
+             default=False,
+             is_flag=True)
+@click.option("-i",
+    "--interactive",
+    help="Use interactive search. Allows you to select commands to run.",
+    default=False,
+    is_flag=True)
+@click.option("-dups",
+             "--duplicates",
+             help="Include duplicates",
+             default=False,
+             is_flag=True)
+@click.option("-t",
+             "--timestamps",
+             help="Include timestamps",
+             default=False,
+             is_flag=True)
+@click.option("-V",
+             "--version",
+             help="Print version information",
+             default=False,
+             is_flag=True)
+def bh(query, number, session, directory, system, interactive, duplicates, timestamps, version):
+    """Bashhhub Search
+
+    QUERY - Like string to search for
+    """
+    limit = number
+    system_name = BH_SYSTEM_NAME if system else None
+    path = os.getcwd() if directory else None
+    session_id = session
+
+    # By default show unique on the client.
+    unique = not duplicates
+
+    use_timestamps = timestamps
+
+    # If we're interactive, make sure we have a query
+    if interactive and query == '':
+        query = input("(bashhub-i-search): ")
+
+    if version and query == '':
+        print(version_str)
+        sys.exit()
+
+    # Call our rest api to search for commands
+    commands = rest_client.search(limit=limit,
+                                  path=path,
+                                  query=query,
+                                  system_name=system_name,
+                                  unique=unique,
+                                  session_id=session_id)
+
+    if interactive:
+        run_interactive(commands)
+    else:
+        print_commands(commands, use_timestamps)
+
+
+def print_commands(commands, use_timestamps):
+    for command in reversed(commands):
+        if use_timestamps:
+            timestamp = unix_milliseconds_timestamp_to_datetime(command.created)
+            print('%s\t%s' % (timestamp, command.command))
+        else:
+            print(command.command)
+
+
+def run_interactive(commands):
+    i_search = InteractiveSearch(commands, rest_client)
+    i_search.run()
+    # numpy bullshit since it doesn't return anything.
+    # Consider submitting a patchset for it.
+    command = i_search.return_value
+    if command is not None:
+        f = io.open(BH_HOME + '/response.bh', 'w+', encoding='utf-8')
+        print(command.command, file=f)
+
+def unix_milliseconds_timestamp_to_datetime(timestamp):
+    return datetime.datetime.fromtimestamp(int(timestamp) / 1000) \
+        .strftime('%Y-%m-%d %H:%M:%S')
+
+def main():
+    try:
+        bh()
+    except Exception as e:
+        if BH_DEBUG:
+            traceback.print_exc()
+        click.echo("Oops, look like an exception occured: " + str(e))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        # To allow Ctrl+C (^C). Print a new line to drop the prompt.
+        click.echo()
+        sys.exit()
+
+main()