def _connect():
# Create transport object
try:
transport = paramiko.Transport((HOSTNAME, PORT))
except paramiko.ssh_exception.SSHException:
logging.error("Connection to the host failed. Check hostname and port.")
sys.exit(0)
# Start SSH session based on authentication type
try:
if AUTHENTICATION_TYPE == "password":
# FIXME: Use encrypted KVStore for password
password = CONFIG.get(_name, "password")
transport.connect(username=USERNAME, password=password)
elif AUTHENTICATION_TYPE == "key":
# FIXME: Use encrypted KVStore for password
key_filepath = CONFIG.get(_name, "key_filepath")
key_passphrase = CONFIG.get(_name, "key_passphrase")
private_key = paramiko.RSAKey.from_private_key_file(key_filepath, key_passphrase)
transport.connect(username=USERNAME, pkey=private_key)
else:
logging.error("Unknown authentication type.")
except paramiko.ssh_exception.AuthenticationException:
logging.error("Login failed. Check username and password or private key and passphrase.")
sys.exit(0)
return transport, paramiko.SFTPClient.from_transport(transport)
def upload(file: str) -> str:
flags = Namespace(
auth_host_name="localhost", auth_host_port=[8080, 8090], logging_level="ERROR", noauth_local_webserver=False
)
credentials = _get_credentials(flags)
http = credentials.authorize(httplib2.Http())
service = discovery.build("drive", "v2", http=http)
# Returns a list of folders in the root directory with a title equaling the screenshot_dir
results = (
service.files()
.list(
q="'root' in parents and trashed=false and mimeType='application/vnd.google-apps.folder'"
" and title='" + CONFIG.get(CONFIG.general, "screenshot_dir") + "'",
maxResults=100,
)
.execute()
)
items = results.get("items", [])
# Checks if the directory already exists and if not it will create it
if not items:
folder_body = {
"title": CONFIG.get(CONFIG.general, "screenshot_dir"),
"parents": ["root"],
"mimeType": "application/vnd.google-apps.folder",
}
try:
return_folder = service.files().insert(body=folder_body).execute()
folder_id = return_folder.get("id")
except errors.HttpError as e:
logging.error(e)
return None
else:
folder_id = items[0]["id"]
# Defines some bodies for communicating with Google Drive
media_body = MediaFileUpload(file, resumable=True)
body = {
"title": ntpath.basename(file),
"description": "Screenshot",
"parents": [{"id": folder_id}],
"writersCanShare": True,
}
new_permission = {"role": "reader", "type": "anyone"}
try:
# Uploads the file to Drive
return_file = service.files().insert(body=body, media_body=media_body).execute()
logging.info("Google Drive upload done")
# Shares the file so everybody with the link can read it
service.permissions().insert(fileId=return_file["id"], body=new_permission).execute()
logging.info("Google Drive permissions set")
# Inserts the file ID into another URL for a better image view in the browser
ret_str = "http://drive.google.com/uc?export=view&id=" + return_file["selfLink"].split("/files/")[1]
return ret_str
except errors.HttpError as e:
logging.info(e)
return None
def upload(file: str):
# Upload preparations
transport, sftp_client = _connect()
try:
sftp_client.chdir(SFTP_BASE_DIR)
except IOError:
logging.error(
"Can not change into base directory. Please provide a working base directory in your SFTP configuration.")
sys.exit(0)
screenshot_dir = CONFIG.get(CONFIG.general, "screenshot_dir")
sftp_filepath = screenshot_dir + "/" + ntpath.basename(file)
_create_dir_if_not_exists(screenshot_dir, sftp_client)
# Upload
try:
sftp_client.put(file, sftp_filepath)
except IOError:
# State reason for failue without exposing Traceback? Is IOError the correct exception?
# Documentation: http://docs.paramiko.org/en/2.0/api/sftp.html
logging.error("Upload failed.")
# Close
sftp_client.close()
transport.close()
return "http://" + HOSTNAME + "/" + sftp_filepath
def upload(file: str) -> str:
# TODO: Use another way to find out if the access token is valid
# FIXME: Check for authorization failure
if "access_token" not in kvstore.keys():
authorization_successful = _authorize()
if not authorization_successful:
return None # unable to upload without successful authorization
token = kvstore["access_token"]
dropbox_client = dropbox.Dropbox(token)
dropbox_filepath = "/" + CONFIG.get(CONFIG.general, "screenshot_dir") + "/" + ntpath.basename(file)
file_object = open(file, 'rb')
try:
dropbox_client.files_upload(
file_object,
dropbox_filepath,
mode=WriteMode("overwrite", None),
client_modified=None,
mute=False
)
except dropbox.exceptions.ApiError as e:
logging.error("Upload failed. Error message: {0}".format(e.error_msg))
return None
try:
url = dropbox_client.sharing_create_shared_link_with_settings(dropbox_filepath, None).url
except dropbox.exceptions.ApiError as e:
logging.error("Could not create shared link. Error message: {0}".format(e.error_msg))
return None
return _change_url_suffix(url)
def main(argv):
args = docopt(__doc__, argv=argv)
# import modules dynamically
scrtool = args["--tool"] if args["--tool"] else CONFIG.get(CONFIG.general, "screenshot_tool")
storage = args["--storage"] if args["--storage"] else CONFIG.get(CONFIG.general, "storage")
scrtool = import_module("screenshot." + scrtool)
storage = import_module("storage." + storage)
# build filename
file = "{}/instantscreen_{}.png".format(gettempdir(), strftime("%Y-%m-%d_%H-%I-%S"))
# take screenshot
if args["--whole"]:
scrtool.take_screenshot_whole(file)
else:
scrtool.take_screenshot_crop(file)
if not os.path.isfile(file):
# Capture screen cancelled
logging.debug("Screen capture cancelled.")
return
# upload to storage
url = storage.upload(file)
logging.info("Uploaded screenshot to: " + url)
# execute user defined action
if CONFIG.getboolean(CONFIG.general, "cb_autocopy"):
import tools.clipboard as c
c.Clipboard().set(url)
else:
import webbrowser as w
w.open_new_tab(url)
# notify user if set
if CONFIG.getboolean(CONFIG.general, "notification_sound"):
import tools.audio as a
a.play_wave_file("res/notification.wav")
def _authorize():
authorization_endpoint = "https://www.dropbox.com/oauth2/authorize"
app_key = CONFIG.get(_name, "app_key")
# Start OAuth2 implicit flow
auth_response = implicit_flow(authorization_endpoint, app_key)
# Check if authorization was successful
if "error" in auth_response and auth_response["error"] is not None:
logging.error("Authentication failed. Error message: {0}".format(auth_response["error_description"]))
return False
kvstore["access_token"] = auth_response["access_token"]
kvstore.sync()
return True
def upload(file: str) -> str:
# Anonymous upload.
# TODO: Upload to a specific user account. See #8.
client_id = CONFIG.get(_name, "client_id")
# access_token = kvstore["access_token"]
# refresh_token = kvstore["refresh_token"]
imgur_client = ImgurClient(client_id, None, None, None)
file_metadata = None
try:
file_metadata = imgur_client.upload_from_path(file)
except ImgurClientError as e:
logging.error("Upload failed. Error message: {0}".format(e.error_message))
url = file_metadata["link"] if file_metadata else None
return url
def _authorize():
# For issue #8
authorization_endpoint = "https://api.imgur.com/oauth2/authorize"
client_id = CONFIG.get(_name, "client_id")
# Start OAuth2 implicit flow
auth_response = implicit_flow(authorization_endpoint, client_id)
# Check if authorization was successful
if "error" in auth_response and auth_response["error"] is not None:
logging.error("Authentication failed. Error message: {0}".format(auth_response["error_description"]))
return False
kvstore["access_token"] = auth_response["access_token"]
kvstore["refresh_token"] = auth_response["refresh_token"]
kvstore["expires_in"] = auth_response["expires_in"]
kvstore.sync()
return True
def main(argv):
args = docopt(__doc__, argv)
# Event Queue for main thread
event_queue = Queue()
# define callbacks for menu items in system tray context menu
tray_callbacks = (
lambda: delay_execution(0.3, lambda: execute_command("screen --whole")),
lambda: delay_execution(0.3, lambda: execute_command("screen"))
)
# assign callbacks to hotkey options of config file
hotkey_options_with_callbacks = {
"screenshot_whole": lambda: execute_command("screen --whole"),
"screenshot_crop": lambda: execute_command("screen")
}
# parse hotkeys from config file and add them to hotkey daemon
hotkey_daemon = Hotkey(event_queue)
for hotkey_option, callback in hotkey_options_with_callbacks.items():
try:
hotkey = CONFIG.get("hotkeys", hotkey_option).split("+")
hotkey_daemon.add_hotkey(hotkey, callback)
except (HotkeyInUseError, InvalidHotkeyError) as e:
logging.warning(e.error_msg)
# enable hotkey functionality
hotkey_daemon.listen()
# create tray
logging.info("Creating tray icon for instantshare")
traymenu_daemon = Tray(event_queue, *tray_callbacks)
traymenu_daemon.show()
while True:
event = event_queue.get()
event()
import logging
import ntpath
import sys
import paramiko
from tools.config import CONFIG
from tools.persistence import KVStore
_name = "sftp"
# TODO: encryption
kvstore = KVStore(_name)
# Load SFTP server info from config file
HOSTNAME = CONFIG.get(_name, "hostname")
PORT = CONFIG.getint(_name, "port")
USERNAME = CONFIG.get(_name, "username")
AUTHENTICATION_TYPE = CONFIG.get(_name, "authentication_type")
SFTP_BASE_DIR = CONFIG.get(_name, "base_dir")
# The provided user for SFTP upload must have read and write permissions in the SFTP_BASE_DIR
# (The SFTP_BASE_DIR has to exist, the user doesn't need permissions in the parent directory).
# A lack of permissions in SFTP_BASE_DIR will break the SFTP upload functionality.
def upload(file: str):
# Upload preparations
transport, sftp_client = _connect()
try:
sftp_client.chdir(SFTP_BASE_DIR)
