Madiator2011/lbry-sdk
1
0
Fork 0
forked from LBRYCommunity/lbry-sdk
Code Pull requests Activity

Merge pull request #23 from lbryio/jsonrpc

Browse source 
Jsonrpc
This commit is contained in:
Jack Robison 2016-03-23 22:37:29 -04:00
commit 37b5f22c1a
11 changed files with 237 additions and 309 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
lbrynet/conf.py
View file

@ -27,3 +27,17 @@ POINTTRADER_SERVER = 'http://ec2-54-187-192-68.us-west-2.compute.amazonaws.com:2
#POINTTRADER_SERVER = 'http://127.0.0.1:2424' #POINTTRADER_SERVER = 'http://127.0.0.1:2424'
CRYPTSD_FILE_EXTENSION = ".cryptsd" CRYPTSD_FILE_EXTENSION = ".cryptsd"
API_INTERFACE = "localhost"
API_ADDRESS = "lbryapi"
API_PORT = 5279
ICON_PATH = "app.icns"
APP_NAME = "LBRY"
DEFAULT_WALLET = "lbryum"
API_CONNECTION_STRING = "http://%s:%i/%s" % (API_INTERFACE, API_PORT, API_ADDRESS)
UI_ADDRESS = "http://" + API_INTERFACE + ":" + str(API_PORT)
PROTOCOL_PREFIX = "lbry"
DEFAULT_TIMEOUT = 30

43
lbrynet/lbryfilemanager/LBRYFileManager.py
View file

@ -3,9 +3,9 @@ Keep track of which LBRY Files are downloading and store their LBRY File specifi
""" """
import logging import logging
import datetime
import os import os
import sys import sys
from datetime import datetime
from twisted.internet.task import LoopingCall from twisted.internet.task import LoopingCall
from twisted.enterprise import adbapi from twisted.enterprise import adbapi
@ -28,13 +28,14 @@ class LBRYFileManager(object):
Keeps track of currently opened LBRY Files, their options, and their LBRY File specific metadata. Keeps track of currently opened LBRY Files, their options, and their LBRY File specific metadata.
""" """
def __init__(self, session, stream_info_manager, sd_identifier): def __init__(self, session, stream_info_manager, sd_identifier, delete_data=False):
self.session = session self.session = session
self.stream_info_manager = stream_info_manager self.stream_info_manager = stream_info_manager
self.sd_identifier = sd_identifier self.sd_identifier = sd_identifier
self.lbry_files = [] self.lbry_files = []
self.sql_db = None self.sql_db = None
self.check_exists_loop = LoopingCall(self.check_files_exist) # self.delete_data = delete_data
# self.check_exists_loop = LoopingCall(self.check_files_exist)
if sys.platform.startswith("darwin"): if sys.platform.startswith("darwin"):
self.download_directory = os.path.join(os.path.expanduser("~"), 'Downloads') self.download_directory = os.path.join(os.path.expanduser("~"), 'Downloads')
else: else:
@ -42,24 +43,34 @@ class LBRYFileManager(object):
log.debug("Download directory for LBRYFileManager: %s", str(self.download_directory)) log.debug("Download directory for LBRYFileManager: %s", str(self.download_directory))
def setup(self): def setup(self):
self.check_exists_loop.start(1) # self.check_exists_loop.start(10)
d = self._open_db() d = self._open_db()
d.addCallback(lambda _: self._add_to_sd_identifier()) d.addCallback(lambda _: self._add_to_sd_identifier())
d.addCallback(lambda _: self._start_lbry_files()) d.addCallback(lambda _: self._start_lbry_files())
return d return d
def check_files_exist(self): # def check_files_exist(self):
def _disp(deleted_files): # def _disp(deleted_files):
if deleted_files[0][0]: # if deleted_files[0][0]:
for file in bad_files: # for file in bad_files:
print "[" + str(datetime.datetime.now()) + "] Detected " + file.file_name + " was deleted, removing from file manager" # log.info("[" + str(datetime.now()) + "] Detected " + file.file_name + " was deleted, removing from file manager")
#
bad_files = [lbry_file for lbry_file in self.lbry_files # def _delete_stream_data(lbry_file):
if lbry_file.completed == True and # s_h = lbry_file.stream_hash
os.path.isfile(os.path.join(self.download_directory, lbry_file.file_name)) == False] # d = self.get_count_for_stream_hash(s_h)
d = defer.DeferredList([self.delete_lbry_file(lbry_file) for lbry_file in bad_files], consumeErrors=True) # # TODO: could possibly be a timing issue here
d.addCallback(lambda files: _disp(files) if len(files) else defer.succeed(None)) # d.addCallback(lambda c: self.stream_info_manager.delete_stream(s_h) if c == 0 else True)
# return d
#
# bad_files = [lbry_file for lbry_file in self.lbry_files
# if lbry_file.completed == True and
# os.path.isfile(os.path.join(self.download_directory, lbry_file.file_name)) == False]
# d = defer.DeferredList([self.delete_lbry_file(lbry_file) for lbry_file in bad_files], consumeErrors=True)
# d.addCallback(lambda files: _disp(files) if len(files) else defer.succeed(None))
#
# if self.delete_data:
# d2 = defer.DeferredList([_delete_stream_data(lbry_file) for lbry_file in bad_files], consumeErrors=True)
def get_lbry_file_status(self, lbry_file): def get_lbry_file_status(self, lbry_file):
return self._get_lbry_file_status(lbry_file.rowid) return self._get_lbry_file_status(lbry_file.rowid)
@ -169,7 +180,7 @@ class LBRYFileManager(object):
return defer.fail(Failure(ValueError("Could not find that LBRY file"))) return defer.fail(Failure(ValueError("Could not find that LBRY file")))
def stop(self): def stop(self):
self.check_exists_loop.stop() # self.check_exists_loop.stop()
ds = [] ds = []

97
lbrynet/lbrynet_daemon/Apps/LBRYURIHandler.py
View file

@ -1,54 +1,79 @@
import os import os
import json import json
import webbrowser import webbrowser
import xmlrpclib, sys import sys
from time import sleep
import subprocess
def render_video(path): from jsonrpc.proxy import JSONRPCProxy
r = r'<center><video src="' + path + r'" controls autoplay width="960" height="720"></center>'
return r API_CONNECTION_STRING = "http://localhost:5279/lbryapi"
UI_ADDRESS = "http://localhost:5279"
def main(args): class LBRYURIHandler(object):
if len(args) == 0: def __init__(self):
args.append('lbry://wonderfullife') self.started_daemon = False
self.start_timeout = 0
self.daemon = JSONRPCProxy.from_url(API_CONNECTION_STRING)
daemon = xmlrpclib.ServerProxy('http://localhost:7080/') def check_status(self):
status = None
try:
status = json.loads(self.daemon.is_running())['result']
if self.start_timeout < 30 and not status:
sleep(1)
self.start_timeout += 1
self.check_status()
elif status:
return True
else:
exit(1)
except:
if self.start_timeout < 30:
sleep(1)
self.start_timeout += 1
self.check_status()
else:
exit(1)
try: def handle(self, lbry_name):
daemon.is_running() lbry_process = [d for d in subprocess.Popen(['ps','aux'], stdout=subprocess.PIPE).stdout.readlines()
if 'LBRY.app' in d]
if len(args) > 1: try:
exit(1) status = json.loads(self.daemon.is_running())['result']
except:
if args[0][7:] == 'lbry': pass
daemon.render_gui()
elif args[0][7:] == 'settings':
r = daemon.get_settings()
html = "<body>" + json.dumps(r) + "</body>"
daemon.render_html(html)
if lbry_process:
self.check_status()
started = False
else: else:
r = daemon.get(args[0][7:]) os.system("open /Applications/LBRY.app")
if r[0] == 200: self.check_status()
path = r[1]['path'] started = True
if path[0] != '/':
path = '/' + path
filename = os.path.basename(path) if lbry_name == "lbry" or lbry_name == "" and not started:
extension = os.path.splitext(filename)[1] webbrowser.get('safari').open(UI_ADDRESS)
else:
if extension in ['mp4', 'flv', 'mov']: r = json.loads(self.daemon.get({'name': lbry_name}))
html = render_video(path) if r['code'] == 200:
daemon.render_html(html) path = r['result']['path'].encode('utf-8')
extension = os.path.splitext(path)[1]
if extension in ['mp4', 'flv', 'mov', 'ogv']:
webbrowser.get('safari').open(UI_ADDRESS + "/view?name=" + lbry_name)
else: else:
webbrowser.get('safari').open('file://' + str(path)) webbrowser.get('safari').open('file://' + path)
else: else:
webbrowser.get('safari').open('http://lbry.io/get') webbrowser.get('safari').open('http://lbry.io/get')
except:
webbrowser.get('safari').open('http://lbry.io/get') def main(args):
if len(args) != 1:
args = ['lbry://lbry']
name = args[0][7:]
LBRYURIHandler().handle(lbry_name=name)
if __name__ == "__main__": if __name__ == "__main__":

70
lbrynet/lbrynet_daemon/LBRYDaemonControl.py Normal file
View file

@ -0,0 +1,70 @@
import argparse
import logging
import tempfile
import os
import shutil
from StringIO import StringIO
from zipfile import ZipFile
from urllib import urlopen
from twisted.web import server, static
from twisted.internet import reactor, defer
from jsonrpc.proxy import JSONRPCProxy
from lbrynet.lbrynet_daemon.LBRYDaemon import LBRYDaemon, LBRYindex, LBRYDaemonWeb, LBRYFileRender
from lbrynet.conf import API_CONNECTION_STRING, API_INTERFACE, API_ADDRESS, API_PORT, DEFAULT_WALLET
log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stop():
def _disp_shutdown():
log.info("Shutting down lbrynet-daemon from command line")
def _disp_not_running():
log.info("Attempt to shut down lbrynet-daemon from command line when daemon isn't running")
d = defer.Deferred(None)
d.addCallback(lambda _: JSONRPCProxy.from_url(API_CONNECTION_STRING).stop())
d.addCallbacks(lambda _: _disp_shutdown(), lambda _: _disp_not_running())
d.callback(None)
def start():
parser = argparse.ArgumentParser(description="Launch lbrynet-daemon")
parser.add_argument("--wallet",
help="lbrycrd or lbryum, default lbryum",
type=str,
default=DEFAULT_WALLET)
parser.add_argument("--update",
help="True or false, default true",
type=str,
default="True")
log.info("Starting lbrynet-daemon from command line")
tmpdir = tempfile.mkdtemp()
url = urlopen("https://rawgit.com/lbryio/lbry-web-ui/master/dist.zip")
z = ZipFile(StringIO(url.read()))
z.extractall(tmpdir)
args = parser.parse_args()
daemon = LBRYDaemon()
daemon.setup(args.wallet, args.update)
root = LBRYindex(tmpdir)
root.putChild("css", static.File(os.path.join(tmpdir, "css")))
root.putChild("font", static.File(os.path.join(tmpdir, "font")))
root.putChild("img", static.File(os.path.join(tmpdir, "img")))
root.putChild("js", static.File(os.path.join(tmpdir, "js")))
root.putChild(API_ADDRESS, daemon)
root.putChild("webapi", LBRYDaemonWeb())
root.putChild("view", LBRYFileRender())
reactor.listenTCP(API_PORT, server.Site(root), interface=API_INTERFACE)
reactor.run()
shutil.rmtree(tmpdir)

84
lbrynet/lbrynet_daemon/LBRYDownloader.py
View file

@ -1,19 +1,23 @@
import json import json
import logging import logging
import os import os
from datetime import datetime from datetime import datetime
from twisted.internet import defer from twisted.internet import defer
from twisted.internet.task import LoopingCall from twisted.internet.task import LoopingCall
from lbrynet.core.Error import InvalidStreamInfoError, InsufficientFundsError from lbrynet.core.Error import InvalidStreamInfoError, InsufficientFundsError
from lbrynet.core.PaymentRateManager import PaymentRateManager from lbrynet.core.PaymentRateManager import PaymentRateManager
from lbrynet.core.StreamDescriptor import download_sd_blob from lbrynet.core.StreamDescriptor import download_sd_blob
from lbrynet.lbryfilemanager.LBRYFileDownloader import ManagedLBRYFileDownloaderFactory from lbrynet.lbryfilemanager.LBRYFileDownloader import ManagedLBRYFileDownloaderFactory
from lbrynet.conf import DEFAULT_TIMEOUT
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
class GetStream(object): class GetStream(object):
def __init__(self, sd_identifier, session, wallet, lbry_file_manager, max_key_fee, pay_key=True, data_rate=0.5): def __init__(self, sd_identifier, session, wallet, lbry_file_manager, max_key_fee, pay_key=True, data_rate=0.5,
timeout=DEFAULT_TIMEOUT):
self.wallet = wallet self.wallet = wallet
self.resolved_name = None self.resolved_name = None
self.description = None self.description = None
@ -30,8 +34,25 @@ class GetStream(object):
self.max_key_fee = max_key_fee self.max_key_fee = max_key_fee
self.stream_info = None self.stream_info = None
self.stream_info_manager = None self.stream_info_manager = None
self.d = defer.Deferred(None)
self.timeout = timeout
self.timeout_counter = 0
self.download_path = None
self.checker = LoopingCall(self.check_status)
def check_status(self):
self.timeout_counter += 1
if self.download_path and os.path.isfile(self.download_path):
self.checker.stop()
return defer.succeed(True)
elif self.timeout_counter >= self.timeout:
log.info("Timeout downloading " + str(self.stream_info))
self.checker.stop()
self.d.cancel()
def start(self, stream_info): def start(self, stream_info):
self.stream_info = stream_info self.stream_info = stream_info
if 'stream_hash' in self.stream_info.keys(): if 'stream_hash' in self.stream_info.keys():
@ -49,28 +70,29 @@ class GetStream(object):
self.stream_hash = self.stream_info['stream_hash'] self.stream_hash = self.stream_info['stream_hash']
else: else:
print 'InvalidStreamInfoError' log.error("InvalidStreamInfoError in autofetcher: ", stream_info)
raise InvalidStreamInfoError(self.stream_info) raise InvalidStreamInfoError(self.stream_info)
if self.key_fee > self.max_key_fee: if self.key_fee > self.max_key_fee:
if self.pay_key: if self.pay_key:
print "Key fee (" + str(self.key_fee) + ") above limit of " + str( log.info("Key fee (" + str(self.key_fee) + ") above limit of " + str(
self.max_key_fee) + ", didn't download lbry://" + str(self.resolved_name) self.max_key_fee) + ", didn't download lbry://" + str(self.resolved_name))
return defer.fail(None) return defer.fail(None)
else: else:
pass pass
d = defer.Deferred(None) self.checker.start(1)
d.addCallback(lambda _: download_sd_blob(self.session, self.stream_hash, self.payment_rate_manager))
d.addCallback(self.sd_identifier.get_metadata_for_sd_blob)
d.addCallback(lambda metadata: (next(factory for factory in metadata.factories if isinstance(factory, ManagedLBRYFileDownloaderFactory)), metadata))
d.addCallback(lambda (factory, metadata): factory.make_downloader(metadata, [self.data_rate, True], self.payment_rate_manager))
d.addErrback(lambda err: err.trap(defer.CancelledError))
d.addErrback(lambda err: log.error("An exception occurred attempting to load the stream descriptor: %s", err.getTraceback()))
d.addCallback(self._start_download)
d.callback(None)
return d self.d.addCallback(lambda _: download_sd_blob(self.session, self.stream_hash, self.payment_rate_manager))
self.d.addCallback(self.sd_identifier.get_metadata_for_sd_blob)
self.d.addCallback(lambda metadata: (next(factory for factory in metadata.factories if isinstance(factory, ManagedLBRYFileDownloaderFactory)), metadata))
self.d.addCallback(lambda (factory, metadata): factory.make_downloader(metadata, [self.data_rate, True], self.payment_rate_manager))
self.d.addErrback(lambda err: err.trap(defer.CancelledError))
self.d.addErrback(lambda err: log.error("An exception occurred attempting to load the stream descriptor: %s", err.getTraceback()))
self.d.addCallback(self._start_download)
self.d.callback(None)
return self.d
def _start_download(self, downloader): def _start_download(self, downloader):
def _pay_key_fee(): def _pay_key_fee():
@ -78,7 +100,7 @@ class GetStream(object):
reserved_points = self.wallet.reserve_points(self.key_fee_address, self.key_fee) reserved_points = self.wallet.reserve_points(self.key_fee_address, self.key_fee)
if reserved_points is None: if reserved_points is None:
return defer.fail(InsufficientFundsError()) return defer.fail(InsufficientFundsError())
print 'Key fee: ' + str(self.key_fee) + ' | ' + str(self.key_fee_address) log.info("Key fee: " + str(self.key_fee) + " | " + str(self.key_fee_address))
return self.wallet.send_points_to_address(reserved_points, self.key_fee) return self.wallet.send_points_to_address(reserved_points, self.key_fee)
return defer.succeed(None) return defer.succeed(None)
@ -89,7 +111,8 @@ class GetStream(object):
downloader.start() downloader.start()
print "Downloading", self.stream_hash, "-->", os.path.join(downloader.download_directory, downloader.file_name) self.download_path = os.path.join(downloader.download_directory, downloader.file_name)
d.addCallback(lambda _: log.info("Downloading " + str(self.stream_hash) + " --> " + str(self.download_path)))
return d return d
@ -117,15 +140,16 @@ class FetcherDaemon(object):
self.is_running = True self.is_running = True
self.search = LoopingCall(self._looped_search) self.search = LoopingCall(self._looped_search)
self.search.start(1) self.search.start(1)
log.info("Starting autofetcher")
else: else:
print "Autofetcher is already running" log.info("Autofetcher is already running")
def stop(self): def stop(self):
if self.is_running: if self.is_running:
self.search.stop() self.search.stop()
self.is_running = False self.is_running = False
else: else:
print "Autofetcher isn't running, there's nothing to stop" log.info("Autofetcher isn't running, there's nothing to stop")
def check_if_running(self): def check_if_running(self):
if self.is_running: if self.is_running:
@ -157,19 +181,15 @@ class FetcherDaemon(object):
return d return d
def get_new_streams_in_tx(claims, t, blockhash): def get_new_streams_in_tx(claims, t, blockhash):
#claims = self.wallet.get_claims_for_tx(t['txid'])
# if self.first_run:
# # claims = self.rpc_conn.getclaimsfortx("96aca2c60efded5806b7336430c5987b9092ffbea9c6ed444e3bf8e008993e11")
# # claims = self.rpc_conn.getclaimsfortx("cc9c7f5225ecb38877e6ca7574d110b23214ac3556b9d65784065ad3a85b4f74")
# self.first_run = False
rtn = [] rtn = []
if claims: if claims:
for claim in claims: for claim in claims:
if claim not in self.seen: if claim not in self.seen:
msg = "[" + str(datetime.now()) + "] New claim | lbry://" + str(claim['name']) + \ msg = "[" + str(datetime.now()) + "] New claim | lbry://" + str(claim['name']) + \
" | stream hash: " + str(json.loads(claim['value'])['stream_hash']) " | stream hash: " + str(json.loads(claim['value'])['stream_hash'])
print msg log.info(msg)
log.debug(msg) if self.verbose:
print msg
rtn.append((claim['name'], t)) rtn.append((claim['name'], t))
self.seen.append(claim) self.seen.append(claim)
else: else:
@ -179,8 +199,6 @@ class FetcherDaemon(object):
d.addCallback(lambda streams: defer.DeferredList( d.addCallback(lambda streams: defer.DeferredList(
[self.wallet.get_stream_info_from_txid(name, t) for name, t in streams])) [self.wallet.get_stream_info_from_txid(name, t) for name, t in streams]))
# if len(rtn):
# return defer.DeferredList([self.wallet.get_stream_info_for_name(name, txid=t) for name, t in rtn])
return d return d
def _download_claims(self, claims): def _download_claims(self, claims):
@ -204,12 +222,12 @@ class FetcherDaemon(object):
for l in conf: for l in conf:
if l.startswith("maxkey="): if l.startswith("maxkey="):
settings["maxkey"] = float(l[7:].rstrip('\n')) settings["maxkey"] = float(l[7:].rstrip('\n'))
print "Autofetcher using max key price of", settings["maxkey"], ", to start call start_fetcher()" conf.close()
else: else:
print "Autofetcher using default max key price of 0.0" conf = open(self.autofetcher_conf, "w")
print "To change this create the file:" conf.write("maxkey=10.0")
print str(self.autofetcher_conf) conf.close()
print "Example contents of conf file:" settings["maxkey"] = 10.0
print "maxkey=1.0" log.info("No autofetcher conf file found, making one with max key fee of 10.0")
self.max_key_fee = settings["maxkey"] self.max_key_fee = settings["maxkey"]

15
lbrynet/lbrynet_daemon/LBRYPublisher.py
View file

@ -33,14 +33,16 @@ class Publisher(object):
self.sd_hash = None self.sd_hash = None
self.tx_hash = None self.tx_hash = None
self.content_license = None self.content_license = None
self.author = None
self.sources = None
def start(self, name, file_path, bid, title=None, description=None, thumbnail=None, def start(self, name, file_path, bid, title=None, description=None, thumbnail=None,
key_fee=None, key_fee_address=None, content_license=None): key_fee=None, key_fee_address=None, content_license=None, author=None, sources=None):
def _show_result(): def _show_result():
message = "[" + str(datetime.now()) + "] Published " + self.file_name + " --> lbry://" + \ message = "[" + str(datetime.now()) + "] Published " + self.file_name + " --> lbry://" + \
str(self.publish_name) + " with txid: " + str(self.tx_hash) str(self.publish_name) + " with txid: " + str(self.tx_hash)
print message log.info(message)
return defer.succeed(message) return defer.succeed(message)
self.publish_name = name self.publish_name = name
@ -52,6 +54,8 @@ class Publisher(object):
self.key_fee = key_fee self.key_fee = key_fee
self.key_fee_address = key_fee_address self.key_fee_address = key_fee_address
self.content_license = content_license self.content_license = content_license
self.author = author
self.sources = sources
d = self._check_file_path(self.file_path) d = self._check_file_path(self.file_path)
d.addCallback(lambda _: create_lbry_file(self.session, self.lbry_file_manager, d.addCallback(lambda _: create_lbry_file(self.session, self.lbry_file_manager,
@ -104,10 +108,11 @@ class Publisher(object):
return d return d
def _claim_name(self): def _claim_name(self):
d = self.wallet.claim_name(self.publish_name, self.sd_hash, self.bid_amount, d = self.wallet.claim_name(self.publish_name, {'sd_hash': self.sd_hash}, self.bid_amount,
description=self.description, key_fee=self.key_fee, description=self.description, key_fee=self.key_fee,
key_fee_address=self.key_fee_address, thumbnail=self.thumbnail, key_fee_address=self.key_fee_address, thumbnail=self.thumbnail,
content_license=self.content_license) content_license=self.content_license, author=self.author,
sources=self.sources)
def set_tx_hash(tx_hash): def set_tx_hash(tx_hash):
self.tx_hash = tx_hash self.tx_hash = tx_hash
@ -122,6 +127,6 @@ class Publisher(object):
else: else:
d = defer.succeed(True) d = defer.succeed(True)
error_message = err.getErrorMessage() error_message = err.getErrorMessage()
print message % (str(self.file_name), str(self.publish_name), error_message) log.error(error_message)
log.error(message, str(self.file_name), str(self.publish_name), err.getTraceback()) log.error(message, str(self.file_name), str(self.publish_name), err.getTraceback())
return d return d

4
lbrynet/lbrynet_daemon/scripts/restart_daemon.sh
View file

@ -1,4 +0,0 @@
#!/bin/sh
echo "Restarting lbrynet-daemon"
lbrynet-daemon

50
lbrynet/lbrynet_daemon/scripts/update_lbry.sh
View file

@ -1,50 +0,0 @@
#!/bin/sh
lbrycrd_directory="/Users/${SUDO_USER}/Library/Application Support/lbrycrd"
current_version=$(git ls-remote https://github.com/jackrobison/lbrynet-app.git | grep HEAD | cut -f 1)
if [ -d "$lbrycrd_directory" ]; then
if [ -f "${lbrycrd_directory}/lbry_app_version.txt" ]; then
if grep -Fxq "$current_version" "${lbrycrd_directory}/lbry_app_version.txt"; then
echo "LBRY version $current_version is up to date"
exit
fi
fi
fi
if ! brew list berkeley-db4 &>/dev/null; then
echo "Installing berkeley-db4"
sudo -u ${SUDO_USER} brew install https://rawgit.com/jackrobison/homebrew/master/Library/Formula/berkeley-db4.rb &>/dev/null
sudo -u ${SUDO_USER} brew link --force berkeley-db4 &>/dev/null
else
echo "berkeley-db4 already installed"
fi
tmp=$(mktemp -d)
cd $tmp
echo "Downloading LBRY update"
git clone --depth 1 https://github.com/jackrobison/lbrynet-app.git &>/dev/null
cd lbrynet-app
unzip LBRY.app.zip &>/dev/null
unzip LBRYURIHandler.app.zip &>/dev/null
unzip LBRY\ Updater.app.zip &>/dev/null
echo "Installing update"
mkdir -p "$lbrycrd_directory"
echo $current_version > "${lbrycrd_directory}/lbry_app_version.txt"
rm -rf /Applications/LBRY.app &>/dev/null
rm -rf /Applications/LBRYURIHandler.app &>/dev/null
rm -rf /Applications/LBRY\ Updater.app &>/dev/null
mv -f LBRY.app /Applications
mv -f LBRYURIHandler.app /Applications
mv -f LBRY\ Updater.app /Applications
echo "Cleaning up"
cd ../../
rm -rf $tmp

163
lbrynet/lbrynet_daemon/scripts/update_lbrynet.sh
View file

@ -1,163 +0,0 @@
#!/bin/sh
if ! which brew &>/dev/null; then
echo "Installing brew..."
sudo -u ${SUDO_USER} ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" < /dev/null &>/dev/null
else
echo "Updating brew..."
sudo -u ${SUDO_USER} brew update &>/dev/null
fi
if ! brew list mpfr &>/dev/null; then
echo "Installing mpfr..."
sudo -u ${SUDO_USER} brew install mpfr &>/dev/null
else
echo "mpfr already installed..."
fi
if ! brew list libmpc &>/dev/null; then
echo "Installing libmpc..."
sudo -u ${SUDO_USER} brew install libmpc &>/dev/null
else
echo "libmpc already installed..."
fi
if ! brew list openssl &>/dev/null; then
echo "Installing openssl..."
sudo -u ${SUDO_USER} brew install openssl &>/dev/null
sudo -u ${SUDO_USER} brew link --force openssl &>/dev/null
else
echo "openssl already installed..."
fi
if ! which pip &>/dev/null; then
echo "Installing pip..."
sudo easy_install pip &>/dev/null
else
echo "pip already installed"
fi
if ! python -c 'import gmpy' &>/dev/null; then
echo "Installing gmpy..."
sudo pip install gmpy &>/dev/null
else
echo "gmpy already installed..."
fi
if ! python -c 'import service_identity' &>/dev/null; then
echo "Installing service_identity..."
sudo pip install service_identity &>/dev/null
else
echo "gmpy already installed..."
fi
if ! python -c 'import rumps' &>/dev/null; then
echo "Installing rumps..."
sudo pip install rumps &>/dev/null
else
echo "rumps already installed..."
fi
if ! python -c "import six; exit(0) if six.__version__ == '1.9.0' else exit(1)" &>/dev/null; then
echo "Installing six 1.9.0 for python..."
curl -O https://pypi.python.org/packages/source/s/six/six-1.9.0.tar.gz &>/dev/null
tar xf six-1.9.0.tar.gz &>/dev/null
cd six-1.9.0
sudo python setup.py install &>/dev/null
cd ..
rm -rf six-1.9.0
rm six-1.9.0.tar.gz
fi
lbrynet_directory="/Users/${SUDO_USER}/Library/Application Support/lbrynet"
lbryum_current_version=$(git ls-remote https://github.com/lbryio/lbryum.git | grep HEAD | cut -f 1)
if [ -d "$lbrynet_directory" ]; then
if [ -f "${lbrynet_directory}/lbryum_version.txt" ]; then
if grep -Fxq "$lbryum_current_version" "${lbrynet_directory}/lbryum_version.txt"; then
echo "LBRYum version $lbryum_current_version is up to date"
else
tmp=$(mktemp -d)
cd $tmp
echo "Downloading LBRYum update..."
git clone --depth 1 https://github.com/lbryio/lbryum.git &>/dev/null
cd lbryum
echo "Installing update..."
sudo python setup.py install &>/dev/null
mkdir -p "$lbrynet_directory"
echo $lbryum_current_version > "${lbrynet_directory}/lbryum_version.txt"
echo "Cleaning up..."
cd ../../
rm -rf $tmp
fi
else
tmp=$(mktemp -d)
cd $tmp
echo "Downloading LBRYum..."
git clone --depth 1 https://github.com/lbryio/lbryum.git &>/dev/null
cd lbryum
echo "Installing..."
sudo python setup.py install &>/dev/null
mkdir -p "$lbrynet_directory"
echo $lbryum_current_version > "${lbrynet_directory}/lbryum_version.txt"
echo "Cleaning up..."
cd ../../
rm -rf $tmp
fi
fi
lbrynet_current_version=$(git ls-remote https://github.com/lbryio/lbry.git | grep HEAD | cut -f 1)
if [ -d "$lbrynet_directory" ]; then
if [ -f "${lbrynet_directory}/lbrynet_version.txt" ]; then
if grep -Fxq "$lbrynet_current_version" "${lbrynet_directory}/lbrynet_version.txt"; then
echo "LBRYnet version $lbrynet_current_version is up to date"
else
tmp=$(mktemp -d)
cd $tmp
echo "Downloading LBRYnet update"
git clone --depth 1 https://github.com/lbryio/lbry.git &>/dev/null
cd lbry
echo "Installing update..."
sudo python setup.py install &>/dev/null
mkdir -p "$lbrynet_directory"
echo $lbrynet_current_version > "${lbrynet_directory}/lbrynet_version.txt"
echo "Cleaning up..."
cd ../../
rm -rf $tmp
fi
else
tmp=$(mktemp -d)
cd $tmp
echo "Downloading LBRYnet..."
git clone --depth 1 https://github.com/lbryio/lbry.git &>/dev/null
cd lbry
echo "Installing..."
sudo python setup.py install &>/dev/null
mkdir -p "$lbrynet_directory"
echo $lbrynet_current_version > "${lbrynet_directory}/lbrynet_version.txt"
echo "Cleaning up..."
cd ../../
rm -rf $tmp
fi
fi

2
setup_uri_handler.py
View file

@ -4,7 +4,9 @@ import os
APP = [os.path.join('lbrynet', 'lbrynet_daemon', 'Apps', 'LBRYURIHandler.py')] APP = [os.path.join('lbrynet', 'lbrynet_daemon', 'Apps', 'LBRYURIHandler.py')]
DATA_FILES = [] DATA_FILES = []
OPTIONS = {'argv_emulation': True, OPTIONS = {'argv_emulation': True,
'packages': ['jsonrpc'],
'plist': { 'plist': {
'LSUIElement': True,
'CFBundleURLTypes': [ 'CFBundleURLTypes': [
{ {
'CFBundleURLTypes': 'LBRYURIHandler', 'CFBundleURLTypes': 'LBRYURIHandler',