From 4705acba559a1b8f979524e1c8071c1c63628f20 Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 02:22:10 -0400 Subject: [PATCH 01/26] use lbryum updateclaim --- lbrynet/core/LBRYMetadata.py | 7 +++++-- lbrynet/core/LBRYWallet.py | 29 ++++++++++++++++++++++------ lbrynet/lbrynet_daemon/LBRYDaemon.py | 15 ++++++++++++++ 3 files changed, 43 insertions(+), 8 deletions(-) diff --git a/lbrynet/core/LBRYMetadata.py b/lbrynet/core/LBRYMetadata.py index 656b55c99..9dde3deda 100644 --- a/lbrynet/core/LBRYMetadata.py +++ b/lbrynet/core/LBRYMetadata.py @@ -90,10 +90,10 @@ class LBRYFeeValidator(dict): class Metadata(dict): - def __init__(self, metadata): + def __init__(self, metadata, is_hex=False): dict.__init__(self) self.meta_version = None - metadata_to_load = deepcopy(metadata) + metadata_to_load = deepcopy(metadata if not is_hex else json.loads(metadata.decode("hex"))) self._verify_sources(metadata_to_load) self._verify_metadata(metadata_to_load) @@ -126,3 +126,6 @@ class Metadata(dict): assert self.meta_version == self['ver'], "version mismatch" break assert metadata == {}, "Unknown metadata keys: %s" % json.dumps(metadata.keys()) + + def serialize(self): + return json.dumps(self).encode("hex") diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 60696624b..2de6f622e 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -425,12 +425,12 @@ class LBRYWallet(object): return d def update_name(self, name, bid, value, old_txid): - d = self._get_value_for_name(name) - d.addCallback(lambda r: self.abandon_name(r['txid'] if not old_txid else old_txid)) - d.addCallback(lambda r: log.info("Abandon claim tx %s" % str(r))) - d.addCallback(lambda _: self.claim_name(name, bid, value)) - - return d + # d = self._get_value_for_name(name) + # d.addCallback(lambda r: self.abandon_name(r['txid'] if not old_txid else old_txid)) + # d.addCallback(lambda r: log.info("Abandon claim tx %s" % str(r))) + # d.addCallback(lambda _: self.claim_name(name, bid, value)) + # return d + return defer.fail(NotImplementedError()) def get_name_and_validity_for_sd_hash(self, sd_hash): d = self._get_claim_metadata_for_sd_hash(sd_hash) @@ -1063,6 +1063,13 @@ class LBRYumWallet(LBRYWallet): d.addCallback(Decimal) return d + def update_name(self, name, bid, value, txid): + serialized = Metadata(value).serialize() + d = self.get_claims_from_tx(txid) + d.addCallback(lambda claims: next(claim['claimId'] for claim in claims if claim['name'] == name)) + d.addCallback(lambda claim_id: self._send_claim_update(txid, bid, name, claim_id, serialized)) + return d + def get_new_address(self): d = threads.deferToThread(self.wallet.create_new_address) d.addCallback(self._save_wallet) @@ -1106,6 +1113,16 @@ class LBRYumWallet(LBRYWallet): d.addCallback(self._broadcast_transaction) return d + def _send_claim_update(self, txid, amount, name, claim_id, val): + def send_claim(address): + cmd = known_commands['updateclaim'] + func = getattr(self.cmd_runner, cmd.name) + return threads.deferToThread(func, txid, address, amount, name, claim_id, val) + log.info("Update lbry://%s %s %f %s %s" % (name, txid, amount, claim_id, val)) + d = self.get_new_address() + d.addCallback(send_claim) + d.addCallback(self._broadcast_transaction) + def _get_decoded_tx(self, raw_tx): tx = Transaction(raw_tx) decoded_tx = {} diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 40f75156f..51f3b0b66 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -2430,6 +2430,21 @@ class LBRYDaemon(jsonrpc.JSONRPC): return d + def jsonrpc_update_claim(self, p): + def _x(r): + log.info(str(r)) + return r + + metadata = p['metadata'] + bid = p['bid'] + name = p['name'] + tx = p['txid'] + d = self.session.wallet.update_name(name, bid, metadata, tx) + d.addCallback(_x) + d.addCallback(lambda r: self._render_response(r, OK_CODE)) + return d + + def get_lbrynet_version_from_github(): """Return the latest released version from github.""" response = requests.get('https://api.github.com/repos/lbryio/lbry/releases/latest') From 4570f687276186216bfa74569f25224ec71ee61d Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 18:44:12 -0400 Subject: [PATCH 02/26] add claim_id to lbry_file and to get_claim_info --- lbrynet/core/LBRYWallet.py | 60 ++++++++++++++++--- lbrynet/lbryfilemanager/LBRYFileDownloader.py | 9 ++- lbrynet/lbrynet_daemon/LBRYDaemon.py | 4 +- 3 files changed, 62 insertions(+), 11 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 2de6f622e..7cfa22717 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -324,6 +324,10 @@ class LBRYWallet(object): for k in ['value', 'txid', 'n', 'height', 'amount']: assert k in r, "getvalueforname response missing field %s" % k + def _log_success(claim_id): + log.info("lbry://%s complies with %s, claimid: %s" % (name, metadata.meta_version, claim_id)) + return defer.succeed(None) + if 'error' in result: log.warning("Got an error looking up a name: %s", result['error']) return Failure(UnknownNameError(name)) @@ -335,8 +339,11 @@ class LBRYWallet(object): except (ValueError, TypeError): return Failure(InvalidStreamInfoError(name)) - d = self._save_name_metadata(name, str(result['txid']), metadata['sources']['lbry_sd_hash']) - d.addCallback(lambda _: log.info("lbry://%s complies with %s" % (name, metadata.meta_version))) + txid = result['txid'] + sd_hash = metadata['sources']['lbry_sd_hash'] + d = self._save_name_metadata(name, txid, sd_hash) + d.addCallback(lambda _: self.get_claimid(name, txid)) + d.addCallback(lambda cid: _log_success(cid)) d.addCallback(lambda _: metadata) return d @@ -345,8 +352,10 @@ class LBRYWallet(object): for k in ['value', 'txid', 'n', 'height', 'amount']: assert k in r, "getvalueforname response missing field %s" % k - def _build_response(m, result): + def _build_response(m, result, claim_id): result['value'] = m + result['claim_id'] = claim_id + log.info("lbry://%s complies with %s, claimid: %s" % (name, m.meta_version, claim_id)) return result if 'error' in result: @@ -360,9 +369,26 @@ class LBRYWallet(object): except (ValueError, TypeError): return Failure(InvalidStreamInfoError(name)) - d = self._save_name_metadata(name, str(result['txid']), metadata['sources']['lbry_sd_hash']) - d.addCallback(lambda _: log.info("lbry://%s complies with %s" % (name, metadata.meta_version))) - d.addCallback(lambda _: _build_response(metadata, result)) + sd_hash = metadata['sources']['lbry_sd_hash'] + txid = result['txid'] + + d = self._save_name_metadata(name, txid, sd_hash) + d.addCallback(lambda _: self.get_claimid(name, txid)) + d.addCallback(lambda claim_id: _build_response(metadata, result, claim_id)) + return d + + def get_claimid(self, name, txid): + def _get_id_for_return(claim_id): + if claim_id: + return defer.succeed(claim_id) + else: + d = self.get_claims_from_tx(txid) + d.addCallback(lambda claims: next(c['claimId'] for c in claims if c['name'] == name)) + d.addCallback(lambda cid: self._update_claimid(cid, name, txid)) + return d + + d = self._get_claimid_for_tx(name, txid) + d.addCallback(_get_id_for_return) return d def get_claim_info(self, name): @@ -370,7 +396,6 @@ class LBRYWallet(object): d.addCallback(lambda r: self._get_claim_info(r, name)) return d - def claim_name(self, name, bid, m): metadata = Metadata(m) @@ -534,10 +559,18 @@ class LBRYWallet(object): def _open_db(self): self.db = adbapi.ConnectionPool('sqlite3', os.path.join(self.db_dir, "blockchainname.db"), check_same_thread=False) - return self.db.runQuery("create table if not exists name_metadata (" + + + def create_tables(transaction): + transaction.execute("create table if not exists name_metadata (" + " name text, " + " txid text, " + " sd_hash text)") + transaction.execute("create table if not exists claim_ids (" + + " claimId text, " + + " name text, " + + " txid text)") + + return self.db.runInteraction(create_tables) def _save_name_metadata(self, name, txid, sd_hash): d = self.db.runQuery("select * from name_metadata where name=? and txid=? and sd_hash=?", (name, txid, sd_hash)) @@ -551,6 +584,17 @@ class LBRYWallet(object): d.addCallback(lambda r: r[0] if len(r) else None) return d + def _update_claimid(self, claim_id, name, txid): + d = self.db.runQuery("delete from claim_ids where claimId=? and name=?", (claim_id, name)) + d.addCallback(lambda r: self.db.runQuery("insert into claim_ids values (?, ?, ?)", (claim_id, name, txid))) + d.addCallback(lambda _: claim_id) + return d + + def _get_claimid_for_tx(self, name, txid): + d = self.db.runQuery("select claimId from claim_ids where name=? and txid=?", (name, txid)) + d.addCallback(lambda r: None if not r else r[0][0]) + return d + ######### Must be overridden ######### def get_balance(self): diff --git a/lbrynet/lbryfilemanager/LBRYFileDownloader.py b/lbrynet/lbryfilemanager/LBRYFileDownloader.py index b01a84708..be6232aa5 100644 --- a/lbrynet/lbryfilemanager/LBRYFileDownloader.py +++ b/lbrynet/lbryfilemanager/LBRYFileDownloader.py @@ -27,6 +27,7 @@ class ManagedLBRYFileDownloader(LBRYFileSaver): self.sd_hash = None self.txid = None self.uri = None + self.claim_id = None self.rowid = rowid self.lbry_file_manager = lbry_file_manager self.saving_status = False @@ -43,10 +44,16 @@ class ManagedLBRYFileDownloader(LBRYFileSaver): return d + def _save_claim_id(claim_id): + self.claim_id = claim_id + return defer.succeed(None) + def _save_claim(name, txid): self.uri = name self.txid = txid - return defer.succeed(None) + d = self.wallet.get_claimid(name, txid) + d.addCallback(_save_claim_id) + return d d.addCallback(_save_sd_hash) d.addCallback(lambda r: _save_claim(r[0], r[1]) if r else None) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 51f3b0b66..c564705a8 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1372,7 +1372,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): 'stream_name': f.stream_name, 'suggested_file_name': f.suggested_file_name, 'upload_allowed': f.upload_allowed, 'sd_hash': f.sd_hash, - 'lbry_uri': f.uri, 'txid': f.txid, + 'lbry_uri': f.uri, 'txid': f.txid, 'claim_id': f.claim_id, 'total_bytes': size, 'written_bytes': written_bytes, 'code': status[0], 'message': message}) @@ -1384,7 +1384,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): 'points_paid': f.points_paid, 'stopped': f.stopped, 'stream_hash': f.stream_hash, 'stream_name': f.stream_name, 'suggested_file_name': f.suggested_file_name, 'upload_allowed': f.upload_allowed, 'sd_hash': f.sd_hash, 'total_bytes': size, - 'written_bytes': written_bytes, 'lbry_uri': f.uri, 'txid': f.txid, + 'written_bytes': written_bytes, 'lbry_uri': f.uri, 'txid': f.txid, 'claim_id': f.claim_id, 'code': status[0], 'message': status[1]}) return d From dfa68f126b26d67b50e5250660ef40259af97233 Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 20:43:39 -0400 Subject: [PATCH 03/26] get update_name in lbrycrdwallet working --- lbrynet/core/LBRYWallet.py | 60 +++++++++++++++------------- lbrynet/lbrynet_daemon/LBRYDaemon.py | 15 +++++-- 2 files changed, 44 insertions(+), 31 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 7cfa22717..cdb11aa57 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -347,7 +347,7 @@ class LBRYWallet(object): d.addCallback(lambda _: metadata) return d - def _get_claim_info(self, result, name): + def _get_claim_info(self, result, name, force_good_metadata=True): def _check_result_fields(r): for k in ['value', 'txid', 'n', 'height', 'amount']: assert k in r, "getvalueforname response missing field %s" % k @@ -355,7 +355,9 @@ class LBRYWallet(object): def _build_response(m, result, claim_id): result['value'] = m result['claim_id'] = claim_id - log.info("lbry://%s complies with %s, claimid: %s" % (name, m.meta_version, claim_id)) + log.info("lbry://%s complies with %s, claimid: %s" % (name, + m.meta_version if force_good_metadata else "not checked", + claim_id)) return result if 'error' in result: @@ -364,16 +366,19 @@ class LBRYWallet(object): _check_result_fields(result) - try: - metadata = Metadata(json.loads(result['value'])) - except (ValueError, TypeError): - return Failure(InvalidStreamInfoError(name)) - - sd_hash = metadata['sources']['lbry_sd_hash'] txid = result['txid'] - d = self._save_name_metadata(name, txid, sd_hash) - d.addCallback(lambda _: self.get_claimid(name, txid)) + if force_good_metadata: + try: + metadata = Metadata(json.loads(result['value'])) + except (ValueError, TypeError): + return Failure(InvalidStreamInfoError(name)) + sd_hash = metadata['sources']['lbry_sd_hash'] + d = self._save_name_metadata(name, txid, sd_hash) + d.addCallback(lambda _: self.get_claimid(name, txid)) + else: + metadata = result['value'] + d = self.get_claimid(name, txid) d.addCallback(lambda claim_id: _build_response(metadata, result, claim_id)) return d @@ -391,9 +396,12 @@ class LBRYWallet(object): d.addCallback(_get_id_for_return) return d - def get_claim_info(self, name): + def get_claim_info(self, name, force_good_metadata=True): + log.info("get claim info") + log.info(name) + log.info(force_good_metadata) d = self._get_value_for_name(name) - d.addCallback(lambda r: self._get_claim_info(r, name)) + d.addCallback(lambda r: self._get_claim_info(r, name, force_good_metadata)) return d def claim_name(self, name, bid, m): @@ -449,13 +457,9 @@ class LBRYWallet(object): d.addCallback(self._get_decoded_tx) return d - def update_name(self, name, bid, value, old_txid): - # d = self._get_value_for_name(name) - # d.addCallback(lambda r: self.abandon_name(r['txid'] if not old_txid else old_txid)) - # d.addCallback(lambda r: log.info("Abandon claim tx %s" % str(r))) - # d.addCallback(lambda _: self.claim_name(name, bid, value)) - # return d - return defer.fail(NotImplementedError()) + def update_name(self, name, txid, value, amount): + d = self._update_name(name, txid, value, amount) + return d def get_name_and_validity_for_sd_hash(self, sd_hash): d = self._get_claim_metadata_for_sd_hash(sd_hash) @@ -630,7 +634,7 @@ class LBRYWallet(object): def _send_abandon(self, txid, address, amount): return defer.fail(NotImplementedError()) - def _update_name(self, txid, value, amount): + def _update_name(self, name, txid, value, amount): return defer.fail(NotImplementedError()) def _do_send_many(self, payments_to_send): @@ -765,7 +769,7 @@ class LBRYcrdWallet(LBRYWallet): def _send_abandon(self, txid, address, amount): return threads.deferToThread(self._send_abandon_rpc, txid, address, amount) - def _update_name(self, txid, value, amount): + def _update_name(self, name, txid, value, amount): return threads.deferToThread(self._update_name_rpc, txid, value, amount) def get_claims_from_tx(self, txid): @@ -922,6 +926,7 @@ class LBRYcrdWallet(LBRYWallet): rpc_conn = self._get_rpc_conn() return rpc_conn.getvalueforname(name) + @_catch_connection_error def _update_name_rpc(self, txid, value, amount): rpc_conn = self._get_rpc_conn() return rpc_conn.updateclaim(txid, value, amount) @@ -1107,11 +1112,10 @@ class LBRYumWallet(LBRYWallet): d.addCallback(Decimal) return d - def update_name(self, name, bid, value, txid): - serialized = Metadata(value).serialize() - d = self.get_claims_from_tx(txid) - d.addCallback(lambda claims: next(claim['claimId'] for claim in claims if claim['name'] == name)) - d.addCallback(lambda claim_id: self._send_claim_update(txid, bid, name, claim_id, serialized)) + def _update_name(self, name, txid, value, amount): + serialized_metadata = Metadata(value).serialize() + d = self.get_claimid(name, txid) + d.addCallback(lambda claim_id: self._send_claim_update(txid, amount, name, claim_id, serialized_metadata)) return d def get_new_address(self): @@ -1178,7 +1182,7 @@ class LBRYumWallet(LBRYWallet): return decoded_tx def _send_abandon(self, txid, address, amount): - log.info("Abandon " + str(txid) + " " + str(address) + " " + str(amount)) + log.info("Abandon %s %s %f" % (txid, address, amount)) cmd = known_commands['abandonclaim'] func = getattr(self.cmd_runner, cmd.name) d = threads.deferToThread(func, txid, address, amount) @@ -1186,7 +1190,7 @@ class LBRYumWallet(LBRYWallet): return d def _broadcast_transaction(self, raw_tx): - log.info("Broadcast: " + str(raw_tx)) + log.info("Broadcast: %s" % str(raw_tx)) cmd = known_commands['broadcast'] func = getattr(self.cmd_runner, cmd.name) d = threads.deferToThread(func, raw_tx) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index c564705a8..f70ea6f99 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -42,6 +42,7 @@ from lbrynet.lbrynet_daemon.LBRYDownloader import GetStream from lbrynet.lbrynet_daemon.LBRYPublisher import Publisher from lbrynet.lbrynet_daemon.LBRYExchangeRateManager import ExchangeRateManager from lbrynet.lbrynet_daemon.Lighthouse import LighthouseClient +from lbrynet.core.LBRYMetadata import Metadata from lbrynet.core import utils from lbrynet.core.LBRYMetadata import verify_name_characters from lbrynet.core.utils import generate_id @@ -2429,17 +2430,25 @@ class LBRYDaemon(jsonrpc.JSONRPC): d.addCallback(lambda r: self._render_response(r, OK_CODE)) return d - def jsonrpc_update_claim(self, p): def _x(r): log.info(str(r)) return r + def _get_metadata_and_txid(old_claim_info): + txid = old_claim_info['txid'] + r = old_claim_info['value'] if isinstance(old_claim_info['value'], dict) else {} + for k in metadata: + r[k] = metadata[k] + return txid, json.dumps(Metadata(r)) + metadata = p['metadata'] bid = p['bid'] name = p['name'] - tx = p['txid'] - d = self.session.wallet.update_name(name, bid, metadata, tx) + + d = self.session.wallet.get_claim_info(name, force_good_metadata=False) + d.addCallback(_get_metadata_and_txid) + d.addCallback(lambda (txid, s): self.session.wallet.update_name(name, txid, s, bid)) d.addCallback(_x) d.addCallback(lambda r: self._render_response(r, OK_CODE)) return d From b0e14fae43c70bc8f325ce3006d4102a9381f1c7 Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 23:08:54 -0400 Subject: [PATCH 04/26] update over existing claim in publish() --- lbrynet/core/LBRYWallet.py | 36 ++++++++++++++++--------- lbrynet/lbrynet_daemon/LBRYDaemon.py | 11 ++------ lbrynet/lbrynet_daemon/LBRYPublisher.py | 16 +++-------- 3 files changed, 28 insertions(+), 35 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index cdb11aa57..90bb7346a 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -396,19 +396,27 @@ class LBRYWallet(object): d.addCallback(_get_id_for_return) return d - def get_claim_info(self, name, force_good_metadata=True): - log.info("get claim info") - log.info(name) - log.info(force_good_metadata) + def get_claim_info(self, name, force_good_metadata=True, is_mine=False): + def _filter_my_claims(claim): + d = self.get_name_claims() + d.addCallback(lambda my_claims: claim if claim['txid'] in [c['txid'] for c in my_claims] else False) + return d + d = self._get_value_for_name(name) d.addCallback(lambda r: self._get_claim_info(r, name, force_good_metadata)) + d.addErrback(lambda _: False) + if is_mine: + d.addCallback(lambda claim: _filter_my_claims(claim) if claim is not False else False) return d def claim_name(self, name, bid, m): - - metadata = Metadata(m) - - d = self._send_name_claim(name, json.dumps(metadata), bid) + def _make_update(old_claim_info): + txid = old_claim_info['txid'] + log.info("Updating from claim tx %s" % txid) + r = old_claim_info['value'] if isinstance(old_claim_info['value'], dict) else {} + for k in metadata: + r[k] = metadata[k] + return self.update_name(name, txid, json.dumps(Metadata(r)), bid) def _save_metadata(txid): log.info("Saving metadata for claim %s" % txid) @@ -416,6 +424,10 @@ class LBRYWallet(object): d.addCallback(lambda _: txid) return d + metadata = Metadata(m) + + d = self.get_claim_info(name, force_good_metadata=False, is_mine=True) + d.addCallback(lambda r: _make_update(r) if r else self._send_name_claim(name, json.dumps(metadata), bid)) d.addCallback(_save_metadata) return d @@ -577,10 +589,8 @@ class LBRYWallet(object): return self.db.runInteraction(create_tables) def _save_name_metadata(self, name, txid, sd_hash): - d = self.db.runQuery("select * from name_metadata where name=? and txid=? and sd_hash=?", (name, txid, sd_hash)) - d.addCallback(lambda r: self.db.runQuery("insert into name_metadata values (?, ?, ?)", (name, txid, sd_hash)) - if not len(r) else None) - + d = self.db.runQuery("delete from name_metadata where name=? and txid=? and sd_hash=?", (name, txid, sd_hash)) + d.addCallback(lambda _: self.db.runQuery("insert into name_metadata values (?, ?, ?)", (name, txid, sd_hash))) return d def _get_claim_metadata_for_sd_hash(self, sd_hash): @@ -596,7 +606,7 @@ class LBRYWallet(object): def _get_claimid_for_tx(self, name, txid): d = self.db.runQuery("select claimId from claim_ids where name=? and txid=?", (name, txid)) - d.addCallback(lambda r: None if not r else r[0][0]) + d.addCallback(lambda r: r[0][0] if r else None) return d ######### Must be overridden ######### diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index f70ea6f99..850b67752 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -379,6 +379,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): log.info("Done writing lbrycrd.conf") def _responseFailed(self, err, call): + log.error(err.getTraceback()) call.cancel() def render(self, request): @@ -2010,12 +2011,6 @@ class LBRYDaemon(jsonrpc.JSONRPC): metadata['fee'][currency]['address'] = address return defer.succeed(None) - def _delete_data(lbry_file): - txid = lbry_file.txid - d = self._delete_lbry_file(lbry_file, delete_file=False) - d.addCallback(lambda _: txid) - return d - if not self.pending_claim_checker.running: self.pending_claim_checker.start(30) @@ -2031,9 +2026,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): d.addCallback(lambda addr: _set_address(addr, c)) pub = Publisher(self.session, self.lbry_file_manager, self.session.wallet) - d.addCallback(lambda _: self._get_lbry_file_by_uri(name)) - d.addCallbacks(lambda l: None if not l else _delete_data(l), lambda _: None) - d.addCallback(lambda r: pub.start(name, file_path, bid, metadata, r)) + d.addCallback(lambda _: pub.start(name, file_path, bid, metadata)) d.addCallback(lambda txid: self._add_to_pending_claims(name, txid)) d.addCallback(lambda r: self._render_response(r, OK_CODE)) d.addErrback(lambda err: self._render_response(err.getTraceback(), BAD_REQUEST)) diff --git a/lbrynet/lbrynet_daemon/LBRYPublisher.py b/lbrynet/lbrynet_daemon/LBRYPublisher.py index 3e1b78325..17f7cb538 100644 --- a/lbrynet/lbrynet_daemon/LBRYPublisher.py +++ b/lbrynet/lbrynet_daemon/LBRYPublisher.py @@ -43,7 +43,7 @@ class Publisher(object): self.stream_hash = None self.metadata = {} - def start(self, name, file_path, bid, metadata, old_txid): + def start(self, name, file_path, bid, metadata): def _show_result(): log.info("Published %s --> lbry://%s txid: %s", self.file_name, self.publish_name, self.txid) @@ -53,7 +53,6 @@ class Publisher(object): self.file_path = file_path self.bid_amount = bid self.metadata = metadata - self.old_txid = old_txid d = self._check_file_path(self.file_path) d.addCallback(lambda _: create_lbry_file(self.session, self.lbry_file_manager, @@ -106,21 +105,12 @@ class Publisher(object): self.metadata['content-type'] = mimetypes.guess_type(os.path.join(self.lbry_file.download_directory, self.lbry_file.file_name))[0] self.metadata['ver'] = CURRENT_METADATA_VERSION + m = Metadata(self.metadata) - if self.old_txid: - - d = self.wallet.abandon_name(self.old_txid) - d.addCallback(lambda tx: log.info("Abandoned tx %s" % str(tx))) - d.addCallback(lambda _: self.wallet.claim_name(self.publish_name, - self.bid_amount, - Metadata(self.metadata))) - else: - d = self.wallet.claim_name(self.publish_name, - self.bid_amount, - Metadata(self.metadata)) def set_tx_hash(txid): self.txid = txid + d = self.wallet.claim_name(self.publish_name, self.bid_amount, m) d.addCallback(set_tx_hash) return d From ca09592a72b1ac5f757bf45d64f87b603b18b96f Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 23:10:15 -0400 Subject: [PATCH 05/26] make logs easier to scroll through --- lbrynet/lbryfile/LBRYFileMetadataManager.py | 2 +- lbrynet/lbrynet_daemon/LBRYDaemon.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lbrynet/lbryfile/LBRYFileMetadataManager.py b/lbrynet/lbryfile/LBRYFileMetadataManager.py index 45612f9d7..6a27dc624 100644 --- a/lbrynet/lbryfile/LBRYFileMetadataManager.py +++ b/lbrynet/lbryfile/LBRYFileMetadataManager.py @@ -48,7 +48,7 @@ class DBLBRYFileMetadataManager(object): return self._add_blobs_to_stream(stream_hash, blobs, ignore_duplicate_error=True) def get_blobs_for_stream(self, stream_hash, start_blob=None, end_blob=None, count=None, reverse=False): - log.info("Getting blobs for a stream. Count is %s", str(count)) + log.debug("Getting blobs for a stream. Count is %s", str(count)) def get_positions_of_start_and_end(): if start_blob is not None: diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 850b67752..3dbf59077 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1229,7 +1229,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): if not force_refresh: if name in self.name_cache.keys(): if (self._get_long_count_timestamp() - self.name_cache[name]['timestamp']) < self.cache_time: - log.info("Returning cached stream info for lbry://" + name) + log.debug("Returning cached stream info for lbry://" + name) d = defer.succeed(self.name_cache[name]['claim_metadata']) else: log.info("Refreshing stream info for lbry://" + name) @@ -1417,7 +1417,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): d = self._get_lbry_file_by_sd_hash(val) elif search_by == "file_name": d = self._get_lbry_file_by_file_name(val) - d.addCallback(_log_get_lbry_file) + # d.addCallback(_log_get_lbry_file) if return_json: d.addCallback(_get_json_for_return) return d From b29377dc2b3030c1253f35caecb10340495f7749 Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 23:27:10 -0400 Subject: [PATCH 06/26] keep claim id history --- lbrynet/core/LBRYWallet.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 90bb7346a..d64b35188 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -599,7 +599,7 @@ class LBRYWallet(object): return d def _update_claimid(self, claim_id, name, txid): - d = self.db.runQuery("delete from claim_ids where claimId=? and name=?", (claim_id, name)) + d = self.db.runQuery("delete from claim_ids where claimId=? and name=? and txid=?", (claim_id, name, txid)) d.addCallback(lambda r: self.db.runQuery("insert into claim_ids values (?, ?, ?)", (claim_id, name, txid))) d.addCallback(lambda _: claim_id) return d From 28c4e382723e377bceac153974428d28e282090d Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 23:27:25 -0400 Subject: [PATCH 07/26] make line neater --- lbrynet/core/LBRYWallet.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index d64b35188..5708ec916 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -595,7 +595,7 @@ class LBRYWallet(object): def _get_claim_metadata_for_sd_hash(self, sd_hash): d = self.db.runQuery("select name, txid from name_metadata where sd_hash=?", (sd_hash,)) - d.addCallback(lambda r: r[0] if len(r) else None) + d.addCallback(lambda r: r[0] if r else None) return d def _update_claimid(self, claim_id, name, txid): From cb985b5a0351b8cb9d92581bbb454d50d48a6fc4 Mon Sep 17 00:00:00 2001 From: Jack Date: Thu, 4 Aug 2016 23:27:44 -0400 Subject: [PATCH 08/26] log conditions of lbry_file failing to start --- lbrynet/lbryfilemanager/LBRYFileManager.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/lbrynet/lbryfilemanager/LBRYFileManager.py b/lbrynet/lbryfilemanager/LBRYFileManager.py index d805fb38d..22350879e 100644 --- a/lbrynet/lbryfilemanager/LBRYFileManager.py +++ b/lbrynet/lbryfilemanager/LBRYFileManager.py @@ -80,13 +80,16 @@ class LBRYFileManager(object): d.addCallback(lambda downloader: downloader.restore()) return d - def log_error(err): + def log_error(err, rowid, stream_hash, options): log.error("An error occurred while starting a lbry file: %s", err.getErrorMessage()) + log.error(rowid) + log.error(stream_hash) + log.error(options) def start_lbry_files(lbry_files_and_options): for rowid, stream_hash, options in lbry_files_and_options: d = set_options_and_restore(rowid, stream_hash, options) - d.addErrback(log_error) + d.addErrback(lambda err: log_error(err, rowid, stream_hash, options)) return True d = self._get_all_lbry_files() From 66ae865de0f6a05f61ed44e65e84efe86411d70c Mon Sep 17 00:00:00 2001 From: Jack Date: Sat, 6 Aug 2016 20:02:51 -0400 Subject: [PATCH 09/26] don't make new lbry file if publish is given a full metadata dict, remove update_claim() --- lbrynet/lbrynet_daemon/LBRYDaemon.py | 59 +++++++++++----------------- 1 file changed, 23 insertions(+), 36 deletions(-) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 3dbf59077..2e7d3160d 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1996,21 +1996,29 @@ class LBRYDaemon(jsonrpc.JSONRPC): Claim txid """ - name = p['name'] - try: - verify_name_characters(name) - except: - log.error("Bad name") - return defer.fail(InvalidNameError("Bad name")) - bid = p['bid'] - file_path = p['file_path'] - metadata = p['metadata'] - def _set_address(address, currency): log.info("Generated new address for key fee: " + str(address)) metadata['fee'][currency]['address'] = address return defer.succeed(None) + name = p['name'] + + try: + verify_name_characters(name) + except AssertionError: + log.error("Bad name") + return defer.fail(InvalidNameError("Bad name")) + + bid = p['bid'] + + try: + metadata = Metadata(p['metadata']) + make_lbry_file = False + except AssertionError: + make_lbry_file = True + metadata = p['metadata'] + file_path = p['file_path'] + if not self.pending_claim_checker.running: self.pending_claim_checker.start(30) @@ -2024,9 +2032,11 @@ class LBRYDaemon(jsonrpc.JSONRPC): if 'address' not in metadata['fee'][c]: d.addCallback(lambda _: self.session.wallet.get_new_address()) d.addCallback(lambda addr: _set_address(addr, c)) - - pub = Publisher(self.session, self.lbry_file_manager, self.session.wallet) - d.addCallback(lambda _: pub.start(name, file_path, bid, metadata)) + if make_lbry_file: + pub = Publisher(self.session, self.lbry_file_manager, self.session.wallet) + d.addCallback(lambda _: pub.start(name, file_path, bid, metadata)) + else: + d.addErrback(lambda _: self.session.wallet.claim_name(name, bid, metadata)) d.addCallback(lambda txid: self._add_to_pending_claims(name, txid)) d.addCallback(lambda r: self._render_response(r, OK_CODE)) d.addErrback(lambda err: self._render_response(err.getTraceback(), BAD_REQUEST)) @@ -2423,29 +2433,6 @@ class LBRYDaemon(jsonrpc.JSONRPC): d.addCallback(lambda r: self._render_response(r, OK_CODE)) return d - def jsonrpc_update_claim(self, p): - def _x(r): - log.info(str(r)) - return r - - def _get_metadata_and_txid(old_claim_info): - txid = old_claim_info['txid'] - r = old_claim_info['value'] if isinstance(old_claim_info['value'], dict) else {} - for k in metadata: - r[k] = metadata[k] - return txid, json.dumps(Metadata(r)) - - metadata = p['metadata'] - bid = p['bid'] - name = p['name'] - - d = self.session.wallet.get_claim_info(name, force_good_metadata=False) - d.addCallback(_get_metadata_and_txid) - d.addCallback(lambda (txid, s): self.session.wallet.update_name(name, txid, s, bid)) - d.addCallback(_x) - d.addCallback(lambda r: self._render_response(r, OK_CODE)) - return d - def get_lbrynet_version_from_github(): """Return the latest released version from github.""" From 3b98508986d972f02277a59cd652a1c6e52a7f34 Mon Sep 17 00:00:00 2001 From: Jack Date: Sun, 7 Aug 2016 16:13:47 -0400 Subject: [PATCH 10/26] clean up claim_name function --- lbrynet/core/LBRYWallet.py | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 5708ec916..415f7378a 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -355,9 +355,10 @@ class LBRYWallet(object): def _build_response(m, result, claim_id): result['value'] = m result['claim_id'] = claim_id - log.info("lbry://%s complies with %s, claimid: %s" % (name, - m.meta_version if force_good_metadata else "not checked", - claim_id)) + log.info("lbry://%s complies with %s, claimid: %s", + name, + m.meta_version if force_good_metadata else "not checked", + claim_id) return result if 'error' in result: @@ -409,15 +410,13 @@ class LBRYWallet(object): d.addCallback(lambda claim: _filter_my_claims(claim) if claim is not False else False) return d - def claim_name(self, name, bid, m): - def _make_update(old_claim_info): - txid = old_claim_info['txid'] - log.info("Updating from claim tx %s" % txid) - r = old_claim_info['value'] if isinstance(old_claim_info['value'], dict) else {} - for k in metadata: - r[k] = metadata[k] - return self.update_name(name, txid, json.dumps(Metadata(r)), bid) + def update_metadata(self, new_metadata, old_metadata): + meta_for_return = old_metadata if isinstance(old_metadata, dict) else {} + for k in new_metadata: + meta_for_return[k] = new_metadata[k] + return Metadata(meta_for_return) + def claim_name(self, name, bid, m): def _save_metadata(txid): log.info("Saving metadata for claim %s" % txid) d = self._save_name_metadata(name, txid, metadata['sources']['lbry_sd_hash']) @@ -427,7 +426,18 @@ class LBRYWallet(object): metadata = Metadata(m) d = self.get_claim_info(name, force_good_metadata=False, is_mine=True) - d.addCallback(lambda r: _make_update(r) if r else self._send_name_claim(name, json.dumps(metadata), bid)) + d.addCallback(lambda r: self.update_name( + name, + r['txid'], + json.dumps(self.update_metadata(metadata, r['value'])), + bid + ) + if r else self._send_name_claim( + name, + json.dumps(metadata), + bid + ) + ) d.addCallback(_save_metadata) return d From f69753f6a0cf5af4a0274199d87abd5331824c1b Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 01:42:37 -0400 Subject: [PATCH 11/26] add get_claims_for_name --- lbrynet/core/LBRYWallet.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 415f7378a..5c989d896 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -408,6 +408,8 @@ class LBRYWallet(object): d.addErrback(lambda _: False) if is_mine: d.addCallback(lambda claim: _filter_my_claims(claim) if claim is not False else False) + def get_claims_for_name(self, name): + d = self._get_claims_for_name(name) return d def update_metadata(self, new_metadata, old_metadata): @@ -639,6 +641,9 @@ class LBRYWallet(object): def get_name_claims(self): return defer.fail(NotImplementedError()) + def _get_claims_for_name(self, name): + return defer.fail(NotImplementedError()) + def _check_first_run(self): return defer.fail(NotImplementedError()) @@ -792,6 +797,9 @@ class LBRYcrdWallet(LBRYWallet): def _update_name(self, name, txid, value, amount): return threads.deferToThread(self._update_name_rpc, txid, value, amount) + def _get_claims_for_name(self, name): + return threads.deferToThread(self._get_claims_for_name_rpc, name) + def get_claims_from_tx(self, txid): return threads.deferToThread(self._get_claims_from_tx_rpc, txid) @@ -926,6 +934,11 @@ class LBRYcrdWallet(LBRYWallet): rpc_conn = self._get_rpc_conn() return rpc_conn.getclaimsfortx(txid) + @_catch_connection_error + def _get_claims_for_name_rpc(self, name): + rpc_conn = self._get_rpc_conn() + return rpc_conn.getclaimsforname(name) + @_catch_connection_error def _get_nametrie_rpc(self): rpc_conn = self._get_rpc_conn() @@ -1181,6 +1194,11 @@ class LBRYumWallet(LBRYWallet): d.addCallback(self._broadcast_transaction) return d + def _get_claims_for_name(self, name): + cmd = known_commands['getclaimsforname'] + func = getattr(self.cmd_runner, cmd.name) + return threads.deferToThread(func, name) + def _send_claim_update(self, txid, amount, name, claim_id, val): def send_claim(address): cmd = known_commands['updateclaim'] From 8d3bd451025f17fb7abafb0fdfeca8be0e4a684f Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 01:43:10 -0400 Subject: [PATCH 12/26] get_claims_for_name daemon function --- lbrynet/lbrynet_daemon/LBRYDaemon.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index d79a06fb0..8b5d8847b 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1999,6 +1999,21 @@ class LBRYDaemon(jsonrpc.JSONRPC): return d + def jsonrpc_get_claims_for_name(self, p): + """ + Get claims for a name + + Args: + 'name': name + Returns + list of name claims + """ + + name = p['name'] + d = self.session.wallet.get_claims_for_name(name) + d.addCallback(lambda r: self._render_response(r, OK_CODE)) + return d + def jsonrpc_get_transaction_history(self): """ Get transaction history From ed55353700586d9c70d351224d7fd7c35a18a2df Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 01:43:28 -0400 Subject: [PATCH 13/26] bug fix --- lbrynet/lbrynet_daemon/LBRYDaemon.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 8b5d8847b..c5df7ef6d 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1188,11 +1188,14 @@ class LBRYDaemon(jsonrpc.JSONRPC): def _get_est_cost(self, name): def _check_est(d, name): - if isinstance(d.result, float): - log.info("Cost est for lbry://" + name + ": " + str(d.result) + "LBC") - else: - log.info("Timeout estimating cost for lbry://" + name + ", using key fee") - d.cancel() + try: + if d.result: + log.info("Cost est for lbry://" + name + ": " + str(d.result) + "LBC") + return defer.succeed(None) + except AttributeError: + pass + log.info("Timeout estimating cost for lbry://" + name + ", using key fee") + d.cancel() return defer.succeed(None) def _add_key_fee(data_cost): From 1523cad044e829f9099d58cd81c79ee54869d3b5 Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 01:46:19 -0400 Subject: [PATCH 14/26] refactor get_claim_info --- lbrynet/core/LBRYWallet.py | 120 +++++++++++++++++++------------------ 1 file changed, 63 insertions(+), 57 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 5c989d896..57d40413a 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -347,40 +347,9 @@ class LBRYWallet(object): d.addCallback(lambda _: metadata) return d - def _get_claim_info(self, result, name, force_good_metadata=True): - def _check_result_fields(r): - for k in ['value', 'txid', 'n', 'height', 'amount']: - assert k in r, "getvalueforname response missing field %s" % k - - def _build_response(m, result, claim_id): - result['value'] = m - result['claim_id'] = claim_id - log.info("lbry://%s complies with %s, claimid: %s", - name, - m.meta_version if force_good_metadata else "not checked", - claim_id) - return result - - if 'error' in result: - log.warning("Got an error looking up a name: %s", result['error']) - return Failure(UnknownNameError(name)) - - _check_result_fields(result) - - txid = result['txid'] - - if force_good_metadata: - try: - metadata = Metadata(json.loads(result['value'])) - except (ValueError, TypeError): - return Failure(InvalidStreamInfoError(name)) - sd_hash = metadata['sources']['lbry_sd_hash'] - d = self._save_name_metadata(name, txid, sd_hash) - d.addCallback(lambda _: self.get_claimid(name, txid)) - else: - metadata = result['value'] - d = self.get_claimid(name, txid) - d.addCallback(lambda claim_id: _build_response(metadata, result, claim_id)) + def get_claim(self, name, claim_id): + d = self.get_claims_for_name(name) + d.addCallback(lambda claims: next(claim for claim in claims['claims'] if claim['claimId'] == claim_id)) return d def get_claimid(self, name, txid): @@ -397,17 +366,54 @@ class LBRYWallet(object): d.addCallback(_get_id_for_return) return d - def get_claim_info(self, name, force_good_metadata=True, is_mine=False): - def _filter_my_claims(claim): - d = self.get_name_claims() - d.addCallback(lambda my_claims: claim if claim['txid'] in [c['txid'] for c in my_claims] else False) + def get_claim_info(self, name, txid=None): + if not txid: + d = self._get_value_for_name(name) + d.addCallback(lambda r: self._get_claim_info(name, r['txid'])) + else: + d = self._get_claim_info(name, txid) + d.addErrback(lambda _: False) + return d + + def _get_claim_info(self, name, txid): + def _build_response(claim): + result = {} + try: + metadata = Metadata(json.loads(claim['value'])) + meta_ver = metadata.meta_version + sd_hash = metadata['sources']['lbry_sd_hash'] + d = self._save_name_metadata(name, txid, sd_hash) + except AssertionError: + metadata = claim['value'] + meta_ver = "Non-compliant" + d = defer.succeed(None) + + claim_id = claim['claimId'] + result['claim_id'] = claim_id + result['amount'] = claim['nEffectiveAmount'] + result['height'] = claim['nHeight'] + result['name'] = name + result['txid'] = txid + result['value'] = metadata + result['supports'] = [{'txid': support['txid'], 'n': support['n']} for support in claim['supports']] + result['meta_version'] = meta_ver + + log.info("lbry://%s metadata: %s, claimid: %s", name, meta_ver, claim_id) + + d.addCallback(lambda _: self.get_name_claims()) + d.addCallback(lambda r: [c['txid'] for c in r]) + d.addCallback(lambda my_claims: _add_is_mine(result, my_claims)) return d - d = self._get_value_for_name(name) - d.addCallback(lambda r: self._get_claim_info(r, name, force_good_metadata)) - d.addErrback(lambda _: False) - if is_mine: - d.addCallback(lambda claim: _filter_my_claims(claim) if claim is not False else False) + def _add_is_mine(response, my_txs): + response['is_mine'] = response['txid'] in my_txs + return response + + d = self.get_claimid(name, txid) + d.addCallback(lambda claim_id: self.get_claim(name, claim_id)) + d.addCallback(_build_response) + return d + def get_claims_for_name(self, name): d = self._get_claims_for_name(name) return d @@ -425,21 +431,21 @@ class LBRYWallet(object): d.addCallback(lambda _: txid) return d - metadata = Metadata(m) + def _claim_or_update(claim, metadata, _bid): + if not claim: + log.info("No claim yet, making a new one") + return self._send_name_claim(name, json.dumps(metadata), _bid) + if not claim['is_mine']: + log.info("Making a contesting claim") + return self._send_name_claim(name, json.dumps(metadata), _bid) + else: + log.info("Updating over own claim") + return self.update_name(name, claim['txid'], json.dumps(self.update_metadata(metadata, claim['value'])), _bid) - d = self.get_claim_info(name, force_good_metadata=False, is_mine=True) - d.addCallback(lambda r: self.update_name( - name, - r['txid'], - json.dumps(self.update_metadata(metadata, r['value'])), - bid - ) - if r else self._send_name_claim( - name, - json.dumps(metadata), - bid - ) - ) + meta = Metadata(m) + + d = self.get_claim_info(name) + d.addCallback(lambda claim: _claim_or_update(claim, meta, bid)) d.addCallback(_save_metadata) return d From f32250f4319fd28ce3f8a65d9ebfd2927ae29618 Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 01:54:41 -0400 Subject: [PATCH 15/26] whoops --- lbrynet/core/LBRYWallet.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 57d40413a..46be98547 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -425,7 +425,7 @@ class LBRYWallet(object): return Metadata(meta_for_return) def claim_name(self, name, bid, m): - def _save_metadata(txid): + def _save_metadata(txid, metadata): log.info("Saving metadata for claim %s" % txid) d = self._save_name_metadata(name, txid, metadata['sources']['lbry_sd_hash']) d.addCallback(lambda _: txid) @@ -446,7 +446,7 @@ class LBRYWallet(object): d = self.get_claim_info(name) d.addCallback(lambda claim: _claim_or_update(claim, meta, bid)) - d.addCallback(_save_metadata) + d.addCallback(lambda txid: _save_metadata(txid, meta)) return d def abandon_name(self, txid): From 02cd8b9a44b27c6f811df3d4ef3d482266cd816b Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 02:08:09 -0400 Subject: [PATCH 16/26] fix callback --- lbrynet/lbrynet_daemon/LBRYDaemon.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index c5df7ef6d..7134a4a53 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1946,7 +1946,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): pub = Publisher(self.session, self.lbry_file_manager, self.session.wallet) d.addCallback(lambda _: pub.start(name, file_path, bid, metadata)) else: - d.addErrback(lambda _: self.session.wallet.claim_name(name, bid, metadata)) + d.addCallback(lambda _: self.session.wallet.claim_name(name, bid, metadata)) d.addCallback(lambda txid: self._add_to_pending_claims(name, txid)) d.addCallback(lambda r: self._render_response(r, OK_CODE)) d.addErrback(lambda err: self._render_response(err.getTraceback(), BAD_REQUEST)) From 72acfa1e0cc3831094fe49a7b9da8c67ddfdec64 Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 02:32:56 -0400 Subject: [PATCH 17/26] add support_claim --- lbrynet/core/LBRYWallet.py | 25 +++++++++++++++++++++++++ lbrynet/lbrynet_daemon/LBRYDaemon.py | 19 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 46be98547..c5c9b49f4 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -482,6 +482,9 @@ class LBRYWallet(object): dl.addCallback(abandon) return dl + def support_claim(self, name, claim_id, amount): + return self._support_claim(name, claim_id, amount) + def get_tx(self, txid): d = self._get_raw_tx(txid) d.addCallback(self._get_decoded_tx) @@ -668,6 +671,9 @@ class LBRYWallet(object): def _update_name(self, name, txid, value, amount): return defer.fail(NotImplementedError()) + def _support_claim(self, name, claim_id, amount): + return defer.fail(NotImplementedError()) + def _do_send_many(self, payments_to_send): return defer.fail(NotImplementedError()) @@ -803,6 +809,9 @@ class LBRYcrdWallet(LBRYWallet): def _update_name(self, name, txid, value, amount): return threads.deferToThread(self._update_name_rpc, txid, value, amount) + def _support_claim(self, name, claim_id, amount): + return threads.deferToThread(self._support_claim_rpc, name, claim_id, amount) + def _get_claims_for_name(self, name): return threads.deferToThread(self._get_claims_for_name_rpc, name) @@ -981,6 +990,11 @@ class LBRYcrdWallet(LBRYWallet): elif 'message' in e.error: raise ValueError(e.error['message']) + @_catch_connection_error + def _support_claim_rpc(self, name, claim_id, amount): + rpc_conn = self._get_rpc_conn() + return rpc_conn.supportclaim(name, claim_id, amount) + @_catch_connection_error def _get_num_addresses_rpc(self): rpc_conn = self._get_rpc_conn() @@ -1233,6 +1247,17 @@ class LBRYumWallet(LBRYWallet): d.addCallback(self._broadcast_transaction) return d + def _support_claim(self, name, claim_id, amount): + def _send_support(d, a, n, c): + cmd = known_commands['supportclaim'] + func = getattr(self.cmd_runner, cmd.name) + d = threads.deferToThread(func, d, a, n, c) + return d + d = self.get_new_address() + d.addCallback(lambda address: _send_support(address, amount, name, claim_id)) + d.addCallback(self._broadcast_transaction) + return d + def _broadcast_transaction(self, raw_tx): log.info("Broadcast: %s" % str(raw_tx)) cmd = known_commands['broadcast'] diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 7134a4a53..d6987aa2c 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1979,6 +1979,25 @@ class LBRYDaemon(jsonrpc.JSONRPC): return d + def jsonrpc_support_claim(self, p): + """ + Support a name claim + + Args: + 'name': name + 'claim_id': claim id of claim to support + 'amount': amount to support by + Return: + txid + """ + + name = p['name'] + claim_id = p['claim_id'] + amount = p['amount'] + d = self.session.wallet.support_claim(name, claim_id, amount) + d.addCallback(lambda r: self._render_response(r, OK_CODE)) + return d + def jsonrpc_get_name_claims(self): """ Get my name claims From 505ece9e3675558ecd063b52e4cad6e40fd9233d Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 02:37:08 -0400 Subject: [PATCH 18/26] add txid param to get_claim_info and update todo note --- lbrynet/lbrynet_daemon/LBRYDaemon.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index d6987aa2c..4089e6d14 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1708,7 +1708,8 @@ class LBRYDaemon(jsonrpc.JSONRPC): return r name = p['name'] - d = self.session.wallet.get_claim_info(name) + txid = p.get('txid', None) + d = self.session.wallet.get_claim_info(name, txid) d.addCallback(_convert_amount_to_float) d.addCallback(lambda r: self._render_response(r, OK_CODE)) return d @@ -1837,7 +1838,7 @@ class LBRYDaemon(jsonrpc.JSONRPC): List of search results """ - # TODO: change this function to "search", and use cached stream size info from the search server + # TODO: change this function to "search" if 'search' in p.keys(): search = p['search'] From 6fe878bdb98f8755925ca68aca43ea3633315182 Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 03:18:32 -0400 Subject: [PATCH 19/26] make load_from_hex a class method --- lbrynet/core/LBRYMetadata.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/lbrynet/core/LBRYMetadata.py b/lbrynet/core/LBRYMetadata.py index 9dde3deda..b8837ad89 100644 --- a/lbrynet/core/LBRYMetadata.py +++ b/lbrynet/core/LBRYMetadata.py @@ -90,10 +90,14 @@ class LBRYFeeValidator(dict): class Metadata(dict): - def __init__(self, metadata, is_hex=False): + @classmethod + def load_from_hex(cls, metadata): + return cls(json.loads(metadata.decode('hex'))) + + def __init__(self, metadata): dict.__init__(self) self.meta_version = None - metadata_to_load = deepcopy(metadata if not is_hex else json.loads(metadata.decode("hex"))) + metadata_to_load = deepcopy(metadata) self._verify_sources(metadata_to_load) self._verify_metadata(metadata_to_load) From 18edbdf404b6d2b4ff6921b06e5b6a6bbd369c98 Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 14:58:31 -0400 Subject: [PATCH 20/26] squelch resolve_name logging --- lbrynet/lbrynet_daemon/LBRYDaemon.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 4089e6d14..18fc68d65 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -2518,7 +2518,7 @@ class _ResolveNameHelper(object): d = self.wallet.get_stream_info_for_name(self.name) d.addCallbacks(self._cache_stream_info, lambda _: defer.fail(UnknownNameError)) else: - log.info("Returning cached stream info for lbry://%s", self.name) + log.debug("Returning cached stream info for lbry://%s", self.name) d = defer.succeed(self.name_data['claim_metadata']) return d From c474411e1b5042822bd9a428d1871e3754078eda Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 16:35:55 -0400 Subject: [PATCH 21/26] delete bad records that got into name_metadata --- lbrynet/core/LBRYWallet.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index c5c9b49f4..007628398 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -90,6 +90,7 @@ class LBRYWallet(object): return True d = self._open_db() + d.addCallback(lambda _: self._clean_bad_records()) d.addCallback(lambda _: self._start()) d.addCallback(lambda _: start_manage()) return d @@ -609,7 +610,12 @@ class LBRYWallet(object): return self.db.runInteraction(create_tables) + def _clean_bad_records(self): + d = self.db.runQuery("delete from name_metadata where length(txid) > 64 or txid is null") + return d + def _save_name_metadata(self, name, txid, sd_hash): + assert len(txid) == 64, "That's not a txid: %s" % str(txid) d = self.db.runQuery("delete from name_metadata where name=? and txid=? and sd_hash=?", (name, txid, sd_hash)) d.addCallback(lambda _: self.db.runQuery("insert into name_metadata values (?, ?, ?)", (name, txid, sd_hash))) return d @@ -620,12 +626,14 @@ class LBRYWallet(object): return d def _update_claimid(self, claim_id, name, txid): + assert len(txid) == 64, "That's not a txid: %s" % str(txid) d = self.db.runQuery("delete from claim_ids where claimId=? and name=? and txid=?", (claim_id, name, txid)) d.addCallback(lambda r: self.db.runQuery("insert into claim_ids values (?, ?, ?)", (claim_id, name, txid))) d.addCallback(lambda _: claim_id) return d def _get_claimid_for_tx(self, name, txid): + assert len(txid) == 64, "That's not a txid: %s" % str(txid) d = self.db.runQuery("select claimId from claim_ids where name=? and txid=?", (name, txid)) d.addCallback(lambda r: r[0][0] if r else None) return d @@ -1259,10 +1267,10 @@ class LBRYumWallet(LBRYWallet): return d def _broadcast_transaction(self, raw_tx): - log.info("Broadcast: %s" % str(raw_tx)) cmd = known_commands['broadcast'] func = getattr(self.cmd_runner, cmd.name) d = threads.deferToThread(func, raw_tx) + d.addCallback(lambda r: r if len(r) == 64 else Exception("Transaction rejected")) d.addCallback(self._save_wallet) return d From 4a5618bcc44934e7a3d99c2ca3d06ee6ed66c0b0 Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 21:32:39 -0400 Subject: [PATCH 22/26] get update claim working with lbryumwallet --- lbrynet/core/LBRYMetadata.py | 3 ++ lbrynet/core/LBRYWallet.py | 45 ++++++++++++------------- lbrynet/lbrynet_daemon/LBRYDaemon.py | 25 +++++++++----- lbrynet/lbrynet_daemon/LBRYPublisher.py | 2 +- 4 files changed, 42 insertions(+), 33 deletions(-) diff --git a/lbrynet/core/LBRYMetadata.py b/lbrynet/core/LBRYMetadata.py index b8837ad89..4405a6408 100644 --- a/lbrynet/core/LBRYMetadata.py +++ b/lbrynet/core/LBRYMetadata.py @@ -133,3 +133,6 @@ class Metadata(dict): def serialize(self): return json.dumps(self).encode("hex") + + def as_json(self): + return json.dumps(self) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 007628398..99aa9a761 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -399,7 +399,7 @@ class LBRYWallet(object): result['supports'] = [{'txid': support['txid'], 'n': support['n']} for support in claim['supports']] result['meta_version'] = meta_ver - log.info("lbry://%s metadata: %s, claimid: %s", name, meta_ver, claim_id) + log.info("get claim info lbry://%s metadata: %s, claimid: %s", name, meta_ver, claim_id) d.addCallback(lambda _: self.get_name_claims()) d.addCallback(lambda r: [c['txid'] for c in r]) @@ -423,7 +423,7 @@ class LBRYWallet(object): meta_for_return = old_metadata if isinstance(old_metadata, dict) else {} for k in new_metadata: meta_for_return[k] = new_metadata[k] - return Metadata(meta_for_return) + return defer.succeed(Metadata(meta_for_return)) def claim_name(self, name, bid, m): def _save_metadata(txid, metadata): @@ -435,13 +435,15 @@ class LBRYWallet(object): def _claim_or_update(claim, metadata, _bid): if not claim: log.info("No claim yet, making a new one") - return self._send_name_claim(name, json.dumps(metadata), _bid) + return self._send_name_claim(name, metadata.as_json(), _bid) if not claim['is_mine']: log.info("Making a contesting claim") - return self._send_name_claim(name, json.dumps(metadata), _bid) + return self._send_name_claim(name, metadata.as_json(), _bid) else: log.info("Updating over own claim") - return self.update_name(name, claim['txid'], json.dumps(self.update_metadata(metadata, claim['value'])), _bid) + d = self.update_metadata(metadata, claim['value']) + d.addCallback(lambda new_metadata: self._send_name_claim_update(name, claim['claim_id'], claim['txid'], new_metadata, _bid)) + return d meta = Metadata(m) @@ -491,10 +493,6 @@ class LBRYWallet(object): d.addCallback(self._get_decoded_tx) return d - def update_name(self, name, txid, value, amount): - d = self._update_name(name, txid, value, amount) - return d - def get_name_and_validity_for_sd_hash(self, sd_hash): d = self._get_claim_metadata_for_sd_hash(sd_hash) d.addCallback(lambda name_txid: self._get_status_of_claim(name_txid[1], name_txid[0], sd_hash) if name_txid is not None else None) @@ -676,7 +674,7 @@ class LBRYWallet(object): def _send_abandon(self, txid, address, amount): return defer.fail(NotImplementedError()) - def _update_name(self, name, txid, value, amount): + def _send_name_claim_update(self, name, claim_id, txid, value, amount): return defer.fail(NotImplementedError()) def _support_claim(self, name, claim_id, amount): @@ -814,7 +812,7 @@ class LBRYcrdWallet(LBRYWallet): def _send_abandon(self, txid, address, amount): return threads.deferToThread(self._send_abandon_rpc, txid, address, amount) - def _update_name(self, name, txid, value, amount): + def _send_name_claim_update(self, name, claim_id, txid, value, amount): return threads.deferToThread(self._update_name_rpc, txid, value, amount) def _support_claim(self, name, claim_id, amount): @@ -1173,12 +1171,6 @@ class LBRYumWallet(LBRYWallet): d.addCallback(Decimal) return d - def _update_name(self, name, txid, value, amount): - serialized_metadata = Metadata(value).serialize() - d = self.get_claimid(name, txid) - d.addCallback(lambda claim_id: self._send_claim_update(txid, amount, name, claim_id, serialized_metadata)) - return d - def get_new_address(self): d = threads.deferToThread(self.wallet.create_new_address) d.addCallback(self._save_wallet) @@ -1227,15 +1219,18 @@ class LBRYumWallet(LBRYWallet): func = getattr(self.cmd_runner, cmd.name) return threads.deferToThread(func, name) - def _send_claim_update(self, txid, amount, name, claim_id, val): - def send_claim(address): + def _send_name_claim_update(self, name, claim_id, txid, value, amount): + def send_claim_update(address): + serialized_metadata = Metadata(value).as_json() #serialize() + log.info("updateclaim %s %s %f %s %s %s" % (txid, address, amount, name, claim_id, serialized_metadata)) cmd = known_commands['updateclaim'] func = getattr(self.cmd_runner, cmd.name) - return threads.deferToThread(func, txid, address, amount, name, claim_id, val) - log.info("Update lbry://%s %s %f %s %s" % (name, txid, amount, claim_id, val)) + return threads.deferToThread(func, txid, address, amount, name, claim_id.decode('hex'), serialized_metadata) + d = self.get_new_address() - d.addCallback(send_claim) + d.addCallback(send_claim_update) d.addCallback(self._broadcast_transaction) + return d def _get_decoded_tx(self, raw_tx): tx = Transaction(raw_tx) @@ -1267,10 +1262,14 @@ class LBRYumWallet(LBRYWallet): return d def _broadcast_transaction(self, raw_tx): + def _log_tx(r): + log.info("Broadcast tx: %s", r) + return r cmd = known_commands['broadcast'] func = getattr(self.cmd_runner, cmd.name) d = threads.deferToThread(func, raw_tx) - d.addCallback(lambda r: r if len(r) == 64 else Exception("Transaction rejected")) + d.addCallback(_log_tx) + d.addCallback(lambda r: r if len(r) == 64 else defer.fail(Exception("Transaction rejected"))) d.addCallback(self._save_wallet) return d diff --git a/lbrynet/lbrynet_daemon/LBRYDaemon.py b/lbrynet/lbrynet_daemon/LBRYDaemon.py index 18fc68d65..af98f3bdd 100644 --- a/lbrynet/lbrynet_daemon/LBRYDaemon.py +++ b/lbrynet/lbrynet_daemon/LBRYDaemon.py @@ -1704,8 +1704,11 @@ class LBRYDaemon(jsonrpc.JSONRPC): """ def _convert_amount_to_float(r): - r['amount'] = float(r['amount']) / 10**8 - return r + if not r: + return False + else: + r['amount'] = float(r['amount']) / 10**8 + return r name = p['name'] txid = p.get('txid', None) @@ -1907,13 +1910,16 @@ class LBRYDaemon(jsonrpc.JSONRPC): Claim txid """ - def _set_address(address, currency): + def _set_address(address, currency, m): log.info("Generated new address for key fee: " + str(address)) - metadata['fee'][currency]['address'] = address - return defer.succeed(None) + m['fee'][currency]['address'] = address + return m name = p['name'] + log.info("Publish: ") + log.info(p) + try: verify_name_characters(name) except AssertionError: @@ -1942,15 +1948,16 @@ class LBRYDaemon(jsonrpc.JSONRPC): for c in metadata['fee']: if 'address' not in metadata['fee'][c]: d.addCallback(lambda _: self.session.wallet.get_new_address()) - d.addCallback(lambda addr: _set_address(addr, c)) + d.addCallback(lambda addr: _set_address(addr, c, metadata)) + else: + d.addCallback(lambda _: metadata) if make_lbry_file: pub = Publisher(self.session, self.lbry_file_manager, self.session.wallet) - d.addCallback(lambda _: pub.start(name, file_path, bid, metadata)) + d.addCallback(lambda meta: pub.start(name, file_path, bid, meta)) else: - d.addCallback(lambda _: self.session.wallet.claim_name(name, bid, metadata)) + d.addCallback(lambda meta: self.session.wallet.claim_name(name, bid, meta)) d.addCallback(lambda txid: self._add_to_pending_claims(name, txid)) d.addCallback(lambda r: self._render_response(r, OK_CODE)) - d.addErrback(lambda err: self._render_response(err.getTraceback(), BAD_REQUEST)) return d diff --git a/lbrynet/lbrynet_daemon/LBRYPublisher.py b/lbrynet/lbrynet_daemon/LBRYPublisher.py index 17f7cb538..614e545b2 100644 --- a/lbrynet/lbrynet_daemon/LBRYPublisher.py +++ b/lbrynet/lbrynet_daemon/LBRYPublisher.py @@ -125,4 +125,4 @@ class Publisher(object): log.error(error_message) log.error(message, str(self.file_name), str(self.publish_name), err.getTraceback()) - return defer.succeed(error_message) + return defer.fail(Exception("Publish failed")) From b7052bba95466b52b28b5d86203600a56b62767c Mon Sep 17 00:00:00 2001 From: Jack Date: Mon, 8 Aug 2016 21:34:05 -0400 Subject: [PATCH 23/26] rename variable --- lbrynet/core/LBRYWallet.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 99aa9a761..4cab6c292 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -1221,11 +1221,11 @@ class LBRYumWallet(LBRYWallet): def _send_name_claim_update(self, name, claim_id, txid, value, amount): def send_claim_update(address): - serialized_metadata = Metadata(value).as_json() #serialize() - log.info("updateclaim %s %s %f %s %s %s" % (txid, address, amount, name, claim_id, serialized_metadata)) + metadata = Metadata(value).as_json() + log.info("updateclaim %s %s %f %s %s %s" % (txid, address, amount, name, claim_id, metadata)) cmd = known_commands['updateclaim'] func = getattr(self.cmd_runner, cmd.name) - return threads.deferToThread(func, txid, address, amount, name, claim_id.decode('hex'), serialized_metadata) + return threads.deferToThread(func, txid, address, amount, name, claim_id.decode('hex'), metadata) d = self.get_new_address() d.addCallback(send_claim_update) From b6da1d776915f5fa1a7d0185a4132c6784f3f6fb Mon Sep 17 00:00:00 2001 From: Jack Date: Tue, 9 Aug 2016 01:26:55 -0400 Subject: [PATCH 24/26] decode and reverse claim id for updateclaim in lbryum --- lbrynet/core/LBRYWallet.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 4cab6c292..0466ebf61 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -1221,11 +1221,12 @@ class LBRYumWallet(LBRYWallet): def _send_name_claim_update(self, name, claim_id, txid, value, amount): def send_claim_update(address): + decoded_claim_id = claim_id.decode('hex')[::-1] metadata = Metadata(value).as_json() - log.info("updateclaim %s %s %f %s %s %s" % (txid, address, amount, name, claim_id, metadata)) + log.info("updateclaim %s %s %f %s %s '%s'", txid, address, amount, name, str(decoded_claim_id), json.dumps(metadata)) cmd = known_commands['updateclaim'] func = getattr(self.cmd_runner, cmd.name) - return threads.deferToThread(func, txid, address, amount, name, claim_id.decode('hex'), metadata) + return threads.deferToThread(func, txid, address, amount, name, decoded_claim_id, metadata) d = self.get_new_address() d.addCallback(send_claim_update) From ef1c059079d2890ed1eb1bb60c12ac56308a8a24 Mon Sep 17 00:00:00 2001 From: Jack Date: Tue, 9 Aug 2016 03:18:44 -0400 Subject: [PATCH 25/26] clean up log line --- lbrynet/core/LBRYWallet.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index d53c29bbb..5e6c06ddd 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -322,7 +322,7 @@ class LBRYWallet(object): assert k in r, "getvalueforname response missing field %s" % k def _log_success(claim_id): - log.info("lbry://%s complies with %s, claimid: %s" % (name, metadata.meta_version, claim_id)) + log.info("lbry://%s complies with %s, claimid: %s", name, metadata.meta_version, claim_id) return defer.succeed(None) if 'error' in result: From 6a1a9ef6bc0d57a883fada90c8df45bcd8bd8756 Mon Sep 17 00:00:00 2001 From: Jack Date: Tue, 9 Aug 2016 03:25:20 -0400 Subject: [PATCH 26/26] encode claim id to be shown in log --- lbrynet/core/LBRYWallet.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lbrynet/core/LBRYWallet.py b/lbrynet/core/LBRYWallet.py index 5e6c06ddd..0bc584aca 100644 --- a/lbrynet/core/LBRYWallet.py +++ b/lbrynet/core/LBRYWallet.py @@ -1219,7 +1219,7 @@ class LBRYumWallet(LBRYWallet): def send_claim_update(address): decoded_claim_id = claim_id.decode('hex')[::-1] metadata = Metadata(value).as_json() - log.info("updateclaim %s %s %f %s %s '%s'", txid, address, amount, name, str(decoded_claim_id), json.dumps(metadata)) + log.info("updateclaim %s %s %f %s %s '%s'", txid, address, amount, name, decoded_claim_id.encode('hex'), json.dumps(metadata)) cmd = known_commands['updateclaim'] func = getattr(self.cmd_runner, cmd.name) return threads.deferToThread(func, txid, address, amount, name, decoded_claim_id, metadata)