forked from LBRYCommunity/lbry-sdk
Merge pull request #620 from lbryio/claim-caching
Add claim caching to wallet storage
This commit is contained in:
Alex Grin
GitHub
commit
89ecd2c571
4 changed files with 385 additions and 127 deletions
|
|
@ -16,6 +16,12 @@ at anytime.
|
|||
*
|
||||
*
|
||||
|
||||
* Added optional `address` and `include_unconfirmed` params to `jsonrpc_wallet_balance` method
|
||||
* Wait for subscriptions before announcing wallet has finished starting
|
||||
* Cache claims in wallet storage for use looking claims up by id or outpoint
|
||||
* Try to use cached claim info for `file_list`
|
||||
* Convert wallet storage to inlinecallbacks
|
||||
|
||||
### Fixed
|
||||
*
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
import datetime
|
||||
import logging
|
||||
import os
|
||||
import json
|
||||
import time
|
||||
|
||||
from twisted.internet import threads, reactor, defer, task
|
||||
from twisted.python.failure import Failure
|
||||
|
|
@ -23,10 +25,11 @@ from lbrynet.core.sqlite_helpers import rerun_if_locked
|
|||
from lbrynet.interfaces import IRequestCreator, IQueryHandlerFactory, IQueryHandler, IWallet
|
||||
from lbrynet.core.client.ClientRequest import ClientRequest
|
||||
from lbrynet.core.Error import RequestCanceledError, InsufficientFundsError, UnknownNameError
|
||||
from lbrynet.db_migrator.migrate1to2 import UNSET_NOUT
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
CLAIM_CACHE_TIME = 600
|
||||
|
||||
|
||||
class ReservedPoints(object):
|
||||
def __init__(self, identifier, amount):
|
||||
|
|
@ -60,6 +63,50 @@ class ClaimOutpoint(dict):
|
|||
return not self.__eq__(compare)
|
||||
|
||||
|
||||
class CachedClaim(object):
|
||||
def __init__(self, claim_id, claim, claim_sequence, address, height, amount, supports,
|
||||
channal_name, signature_is_valid, cache_timestamp, name, txid, nout):
|
||||
self.claim_id = claim_id
|
||||
self.claim = claim
|
||||
self.claim_sequence = claim_sequence
|
||||
self.address = address
|
||||
self.height = height
|
||||
self.amount = amount
|
||||
self.supports = [] if not supports else json.loads(supports)
|
||||
self.effective_amount = self.amount + sum([x['amount'] for x in self.supports])
|
||||
self.channel_name = channal_name
|
||||
self.signature_is_valid = signature_is_valid
|
||||
self.cache_timestamp = cache_timestamp
|
||||
self.name = name
|
||||
self.txid = txid
|
||||
self.nout = nout
|
||||
|
||||
def response_dict(self, check_expires=True):
|
||||
if check_expires and (time.time() - int(self.cache_timestamp)) > CLAIM_CACHE_TIME:
|
||||
return
|
||||
claim = {
|
||||
"height": self.height,
|
||||
"address": self.address,
|
||||
"claim_id": self.claim_id,
|
||||
"claim_sequence": self.claim_sequence,
|
||||
"effective_amount": self.effective_amount,
|
||||
"has_signature": self.claim.has_signature,
|
||||
"name": self.name,
|
||||
"hex": self.claim.serialized.encode('hex'),
|
||||
"value": self.claim.claim_dict,
|
||||
"txid": self.txid,
|
||||
"amount": self.amount,
|
||||
"decoded_claim": True,
|
||||
"supports": self.supports,
|
||||
"nout": self.nout
|
||||
}
|
||||
if self.channel_name is not None:
|
||||
claim['channel_name'] = self.channel_name
|
||||
if self.signature_is_valid is not None:
|
||||
claim['signature_is_valid'] = bool(self.signature_is_valid)
|
||||
return claim
|
||||
|
||||
|
||||
class MetaDataStorage(object):
|
||||
def load(self):
|
||||
return defer.succeed(True)
|
||||
|
|
@ -76,14 +123,38 @@ class MetaDataStorage(object):
|
|||
def update_claimid(self, claim_id, name, claim_outpoint):
|
||||
return defer.succeed(True)
|
||||
|
||||
def get_claimid_for_tx(self, name, claim_outpoint):
|
||||
def get_claimid_for_tx(self, claim_outpoint):
|
||||
return defer.succeed(True)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_cached_claim(self, claim_id, check_expire=True):
|
||||
cache_info = yield self._get_cached_claim(claim_id)
|
||||
response = None
|
||||
if cache_info:
|
||||
cached_claim = CachedClaim(claim_id, *cache_info)
|
||||
response = cached_claim.response_dict(check_expires=check_expire)
|
||||
defer.returnValue(response)
|
||||
|
||||
def _get_cached_claim(self, claim_id):
|
||||
return defer.succeed(None)
|
||||
|
||||
def save_claim_to_cache(self, claim_id, claim_sequence, claim, claim_address, height, amount,
|
||||
supports, channel_name, signature_is_valid):
|
||||
return defer.succeed(True)
|
||||
|
||||
def save_claim_to_uri_cache(self, uri, claim_id, certificate_id=None):
|
||||
return defer.succeed(None)
|
||||
|
||||
def get_cached_claim_for_uri(self, uri, check_expire=True):
|
||||
return defer.succeed(None)
|
||||
|
||||
|
||||
class InMemoryStorage(MetaDataStorage):
|
||||
def __init__(self):
|
||||
self.metadata = {}
|
||||
self.claimids = {}
|
||||
self.claim_dicts = {}
|
||||
self.uri_cache = {}
|
||||
MetaDataStorage.__init__(self)
|
||||
|
||||
def save_name_metadata(self, name, claim_outpoint, sd_hash):
|
||||
|
|
@ -101,24 +172,59 @@ class InMemoryStorage(MetaDataStorage):
|
|||
self.claimids[(name, claim_outpoint['txid'], claim_outpoint['nout'])] = claim_id
|
||||
return defer.succeed(True)
|
||||
|
||||
def get_claimid_for_tx(self, name, claim_outpoint):
|
||||
try:
|
||||
return defer.succeed(
|
||||
self.claimids[(name, claim_outpoint['txid'], claim_outpoint['nout'])])
|
||||
except KeyError:
|
||||
return defer.succeed(None)
|
||||
def get_claimid_for_tx(self, claim_outpoint):
|
||||
result = None
|
||||
for k, claim_id in self.claimids.iteritems():
|
||||
if k[1] == claim_outpoint['txid'] and k[2] == claim_outpoint['nout']:
|
||||
result = claim_id
|
||||
break
|
||||
|
||||
return defer.succeed(result)
|
||||
|
||||
def _get_cached_claim(self, claim_id):
|
||||
claim_cache = self.claim_dicts.get(claim_id, None)
|
||||
claim_tx_cache = None
|
||||
for k, v in self.claimids.iteritems():
|
||||
if v == claim_id:
|
||||
claim_tx_cache = k
|
||||
break
|
||||
|
||||
if claim_cache and claim_tx_cache:
|
||||
cached_claim_args = tuple(claim_cache) + tuple(claim_tx_cache)
|
||||
return defer.succeed(cached_claim_args)
|
||||
return defer.succeed(None)
|
||||
|
||||
def save_claim_to_cache(self, claim_id, claim_sequence, claim, claim_address, height, amount,
|
||||
supports, channel_name, signature_is_valid):
|
||||
self.claim_dicts[claim_id] = (claim, claim_sequence, claim_address, height, amount,
|
||||
supports, channel_name, signature_is_valid, int(time.time()))
|
||||
return defer.succeed(True)
|
||||
|
||||
def save_claim_to_uri_cache(self, uri, claim_id, certificate_id=None):
|
||||
self.uri_cache[uri] = (claim_id, certificate_id)
|
||||
return defer.succeed(None)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_cached_claim_for_uri(self, uri, check_expire=True):
|
||||
result = self.uri_cache.get(uri, None)
|
||||
response = None
|
||||
if result:
|
||||
claim_id, certificate_id = result
|
||||
response = yield self.get_cached_claim(claim_id, check_expire)
|
||||
if response and certificate_id:
|
||||
certificate = yield self.get_cached_claim(certificate_id, check_expire)
|
||||
response['certificate'] = certificate['claim']
|
||||
defer.returnValue(response)
|
||||
|
||||
|
||||
class SqliteStorage(MetaDataStorage):
|
||||
def __init__(self, db_dir):
|
||||
self.db_dir = db_dir
|
||||
self.db = None
|
||||
self.db = adbapi.ConnectionPool('sqlite3', os.path.join(self.db_dir, "blockchainname.db"),
|
||||
check_same_thread=False)
|
||||
MetaDataStorage.__init__(self)
|
||||
|
||||
def load(self):
|
||||
self.db = adbapi.ConnectionPool('sqlite3', os.path.join(self.db_dir, "blockchainname.db"),
|
||||
check_same_thread=False)
|
||||
|
||||
def create_tables(transaction):
|
||||
transaction.execute("create table if not exists name_metadata (" +
|
||||
" name text, " +
|
||||
|
|
@ -130,54 +236,162 @@ class SqliteStorage(MetaDataStorage):
|
|||
" name text, " +
|
||||
" txid text, " +
|
||||
" n integer)")
|
||||
transaction.execute("CREATE TABLE IF NOT EXISTS claim_cache (" +
|
||||
" row_id INTEGER PRIMARY KEY AUTOINCREMENT, " +
|
||||
" claim_id TEXT UNIQUE NOT NULL, " +
|
||||
" claim_sequence INTEGER, " +
|
||||
" claim_address TEXT NOT NULL, " +
|
||||
" height INTEGER NOT NULL, " +
|
||||
" amount INTEGER NOT NULL, " +
|
||||
" supports TEXT, " +
|
||||
" claim_pb TEXT, " +
|
||||
" channel_name TEXT, " +
|
||||
" signature_is_valid BOOL, " +
|
||||
" last_modified TEXT)")
|
||||
transaction.execute("CREATE TABLE IF NOT EXISTS uri_cache (" +
|
||||
" row_id INTEGER PRIMARY KEY AUTOINCREMENT, " +
|
||||
" uri TEXT UNIQUE NOT NULL, " +
|
||||
" cache_row INTEGER, " +
|
||||
" certificate_row INTEGER, " +
|
||||
" last_modified TEXT)")
|
||||
|
||||
return self.db.runInteraction(create_tables)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
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, claim_outpoint, sd_hash):
|
||||
d = self.db.runQuery(
|
||||
"delete from name_metadata where name=? and txid=? and n=? and sd_hash=?",
|
||||
(name, claim_outpoint['txid'], claim_outpoint['nout'], sd_hash))
|
||||
d.addCallback(
|
||||
lambda _: self.db.runQuery(
|
||||
"delete from name_metadata where name=? and txid=? and n=? and sd_hash=?",
|
||||
(name, claim_outpoint['txid'], UNSET_NOUT, sd_hash)))
|
||||
d.addCallback(
|
||||
lambda _: self.db.runQuery(
|
||||
"insert into name_metadata values (?, ?, ?, ?)",
|
||||
(name, claim_outpoint['txid'], claim_outpoint['nout'], sd_hash)))
|
||||
return d
|
||||
yield self.db.runQuery("DELETE FROM name_metadata WHERE LENGTH(txid) > 64 OR txid IS NULL")
|
||||
defer.returnValue(None)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def save_name_metadata(self, name, claim_outpoint, sd_hash):
|
||||
# TODO: refactor the 'name_metadata' and 'claim_ids' tables to not be terrible
|
||||
txid, nout = claim_outpoint['txid'], claim_outpoint['nout']
|
||||
record_exists = yield self.db.runQuery("SELECT COUNT(*) FROM name_metadata "
|
||||
"WHERE name=? AND txid=? AND n=?",
|
||||
(name, txid, nout))
|
||||
if not record_exists:
|
||||
yield self.db.runOperation("INSERT INTO name_metadata VALUES (?, ?, ?, ?)",
|
||||
(name, txid, nout, sd_hash))
|
||||
defer.returnValue(None)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def get_claim_metadata_for_sd_hash(self, sd_hash):
|
||||
d = self.db.runQuery("select name, txid, n from name_metadata where sd_hash=?", (sd_hash,))
|
||||
d.addCallback(lambda r: r[0] if r else None)
|
||||
return d
|
||||
result = yield self.db.runQuery("SELECT name, txid, n FROM name_metadata WHERE sd_hash=?",
|
||||
(sd_hash, ))
|
||||
response = None
|
||||
if result:
|
||||
response = result[0]
|
||||
defer.returnValue(response)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def update_claimid(self, claim_id, name, claim_outpoint):
|
||||
d = self.db.runQuery(
|
||||
"delete from claim_ids where claimId=? and name=? and txid=? and n=?",
|
||||
(claim_id, name, claim_outpoint['txid'], claim_outpoint['nout']))
|
||||
d.addCallback(
|
||||
lambda _: self.db.runQuery(
|
||||
"delete from claim_ids where claimId=? and name=? and txid=? and n=?",
|
||||
(claim_id, name, claim_outpoint['txid'], UNSET_NOUT)))
|
||||
d.addCallback(
|
||||
lambda r: self.db.runQuery(
|
||||
"insert into claim_ids values (?, ?, ?, ?)",
|
||||
(claim_id, name, claim_outpoint['txid'], claim_outpoint['nout'])))
|
||||
d.addCallback(lambda _: claim_id)
|
||||
return d
|
||||
txid, nout = claim_outpoint['txid'], claim_outpoint['nout']
|
||||
yield self.db.runOperation("INSERT OR IGNORE INTO claim_ids VALUES (?, ?, ?, ?)",
|
||||
(claim_id, name, txid, nout))
|
||||
defer.returnValue(claim_id)
|
||||
|
||||
def get_claimid_for_tx(self, name, claim_outpoint):
|
||||
d = self.db.runQuery(
|
||||
"select claimId from claim_ids where name=? and txid=? and n=?",
|
||||
(name, claim_outpoint['txid'], claim_outpoint['nout']))
|
||||
d.addCallback(lambda r: r[0][0] if r else None)
|
||||
return d
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def get_claimid_for_tx(self, claim_outpoint):
|
||||
result = yield self.db.runQuery("SELECT claimId FROM claim_ids "
|
||||
"WHERE txid=? AND n=?",
|
||||
(claim_outpoint['txid'], claim_outpoint['nout']))
|
||||
response = None
|
||||
if result:
|
||||
response = result[0][0]
|
||||
defer.returnValue(response)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def _get_cached_claim(self, claim_id, check_expire=True):
|
||||
r = yield self.db.runQuery("SELECT * FROM claim_cache WHERE claim_id=?", (claim_id, ))
|
||||
claim_tx_info = yield self.db.runQuery("SELECT name, txid, n FROM claim_ids "
|
||||
"WHERE claimId=?", (claim_id, ))
|
||||
response = None
|
||||
if r and claim_tx_info:
|
||||
_, _, seq, claim_address, height, amount, supports, raw, chan_name, valid, ts = r[0]
|
||||
last_modified = int(ts)
|
||||
name, txid, nout = claim_tx_info[0]
|
||||
claim = ClaimDict.deserialize(raw.decode('hex'))
|
||||
response = (claim, seq, claim_address, height, amount, supports,
|
||||
chan_name, valid, last_modified, name, txid, nout)
|
||||
defer.returnValue(response)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def save_claim_to_cache(self, claim_id, claim_sequence, claim, claim_address, height, amount,
|
||||
supports, channel_name, signature_is_valid):
|
||||
serialized = claim.serialized.encode("hex")
|
||||
supports = json.dumps([] or supports)
|
||||
now = str(int(time.time()))
|
||||
|
||||
yield self.db.runOperation("INSERT OR REPLACE INTO claim_cache(claim_sequence, "
|
||||
" claim_id, claim_address, height, "
|
||||
" amount, supports, claim_pb, "
|
||||
" channel_name, signature_is_valid, "
|
||||
" last_modified)"
|
||||
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
(claim_sequence, claim_id, claim_address, height, amount,
|
||||
supports, serialized, channel_name, signature_is_valid, now))
|
||||
defer.returnValue(None)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def save_claim_to_uri_cache(self, uri, claim_id, certificate_id=None):
|
||||
result = yield self.db.runQuery("SELECT row_id, last_modified FROM claim_cache "
|
||||
"WHERE claim_id=?", (claim_id, ))
|
||||
certificate_result = None
|
||||
certificate_row = None
|
||||
|
||||
if certificate_id:
|
||||
certificate_result = yield self.db.runQuery("SELECT row_id FROM claim_cache "
|
||||
"WHERE claim_id=?", (certificate_id, ))
|
||||
if certificate_id is not None and certificate_result is None:
|
||||
log.warning("Certificate is not in cache")
|
||||
elif certificate_result:
|
||||
certificate_row = certificate_result[0][0]
|
||||
|
||||
if result:
|
||||
cache_row, ts = result[0]
|
||||
yield self.db.runOperation("INSERT OR REPLACE INTO uri_cache(uri, cache_row, "
|
||||
" certificate_row, last_modified) "
|
||||
"VALUES (?, ?, ?, ?)",
|
||||
(uri, cache_row, certificate_row,
|
||||
str(int(time.time()))))
|
||||
else:
|
||||
log.warning("Claim is not in cache")
|
||||
defer.returnValue(None)
|
||||
|
||||
@rerun_if_locked
|
||||
@defer.inlineCallbacks
|
||||
def get_cached_claim_for_uri(self, uri, check_expire=True):
|
||||
result = yield self.db.runQuery("SELECT "
|
||||
"claim.claim_id, cert.claim_id, uri_cache.last_modified "
|
||||
"FROM uri_cache "
|
||||
"INNER JOIN claim_cache as claim "
|
||||
"ON uri_cache.cache_row=claim.row_id "
|
||||
"LEFT OUTER JOIN claim_cache as cert "
|
||||
"ON uri_cache.certificate_row=cert.row_id "
|
||||
"WHERE uri_cache.uri=?", (uri, ))
|
||||
response = None
|
||||
if result:
|
||||
claim_id, certificate_id, last_modified = result[0]
|
||||
last_modified = int(last_modified)
|
||||
if check_expire and time.time() - last_modified > CLAIM_CACHE_TIME:
|
||||
defer.returnValue(None)
|
||||
claim = yield self.get_cached_claim(claim_id)
|
||||
if claim:
|
||||
response = {
|
||||
"claim": claim
|
||||
}
|
||||
if response and certificate_id is not None:
|
||||
certificate = yield self.get_cached_claim(certificate_id)
|
||||
response['certificate'] = certificate
|
||||
defer.returnValue(response)
|
||||
|
||||
|
||||
class Wallet(object):
|
||||
|
|
@ -230,9 +444,6 @@ class Wallet(object):
|
|||
def _update_claimid(self, claim_id, name, claim_outpoint):
|
||||
return self._storage.update_claimid(claim_id, name, claim_outpoint)
|
||||
|
||||
def _get_claimid_for_tx(self, name, claim_outpoint):
|
||||
return self._storage.get_claimid_for_tx(name, claim_outpoint)
|
||||
|
||||
@staticmethod
|
||||
def log_stop_error(err):
|
||||
log.error("An error occurred stopping the wallet: %s", err.getTraceback())
|
||||
|
|
@ -452,42 +663,30 @@ class Wallet(object):
|
|||
######
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_claim(self, claim_id):
|
||||
claim = yield self._get_claim_by_claimid(claim_id)
|
||||
if not claim:
|
||||
log.warning("Claim does not exist: %s", claim_id)
|
||||
defer.returnValue(None)
|
||||
try:
|
||||
decoded = smart_decode(claim['value'])
|
||||
claim['value'] = decoded.claim_dict
|
||||
claim['hex'] = decoded.serialized.encode('hex')
|
||||
except DecodeError:
|
||||
claim['hex'] = claim['value']
|
||||
claim['value'] = None
|
||||
claim['error'] = "Failed to decode"
|
||||
log.warning("Failed to decode claim value for lbry://%s#%s", claim['name'],
|
||||
claim['claim_id'])
|
||||
defer.returnValue(claim)
|
||||
def get_cached_claim(self, claim_id, check_expire=True):
|
||||
results = yield self._storage.get_cached_claim(claim_id, check_expire)
|
||||
defer.returnValue(results)
|
||||
|
||||
def get_claimid(self, name, txid, nout):
|
||||
def _get_id_for_return(claim_id):
|
||||
if claim_id:
|
||||
return defer.succeed(claim_id)
|
||||
@defer.inlineCallbacks
|
||||
def get_claim(self, claim_id, check_expire=True):
|
||||
cached_claim = yield self.get_cached_claim(claim_id, check_expire)
|
||||
if cached_claim:
|
||||
result = cached_claim
|
||||
else:
|
||||
log.debug("Refreshing cached claim: %s", claim_id)
|
||||
claim = yield self._get_claim_by_claimid(claim_id)
|
||||
result = None
|
||||
if claim:
|
||||
result = yield self._handle_claim_result(claim)
|
||||
else:
|
||||
d = self.get_claims_from_tx(txid)
|
||||
d.addCallback(
|
||||
lambda claims: next(
|
||||
c for c in claims if c['name'] == name and
|
||||
c['nout'] == claim_outpoint['nout']))
|
||||
d.addCallback(
|
||||
lambda claim: self._update_claimid(
|
||||
claim['claim_id'], name, ClaimOutpoint(txid, claim['nout'])))
|
||||
return d
|
||||
log.warning("Claim does not exist: %s", claim_id)
|
||||
defer.returnValue(result)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_claimid(self, txid, nout):
|
||||
claim_outpoint = ClaimOutpoint(txid, nout)
|
||||
d = self._get_claimid_for_tx(name, claim_outpoint)
|
||||
d.addCallback(_get_id_for_return)
|
||||
return d
|
||||
claim_id = yield self._storage.get_claimid_for_tx(claim_outpoint)
|
||||
defer.returnValue(claim_id)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_my_claim(self, name):
|
||||
|
|
@ -501,19 +700,19 @@ class Wallet(object):
|
|||
defer.returnValue(my_claim)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_claim_info(self, name, txid=None, nout=None, claim_id=None):
|
||||
def get_claim_info(self, name, txid=None, nout=None, claim_id=None, check_expire=True):
|
||||
if claim_id is not None:
|
||||
results = yield self.get_claim(claim_id)
|
||||
results = yield self.get_claim(claim_id, check_expire)
|
||||
if results['name'] != name:
|
||||
raise Exception("Name does not match claim referenced by id")
|
||||
elif txid is None or nout is None:
|
||||
results = yield self.get_claim_by_name(name)
|
||||
else:
|
||||
results = yield self.get_claim_by_outpoint(ClaimOutpoint(txid, nout))
|
||||
results = yield self.get_claim_by_outpoint(ClaimOutpoint(txid, nout), check_expire)
|
||||
defer.returnValue(results)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def _handle_claim_result(self, results):
|
||||
def _handle_claim_result(self, results, update_caches=True):
|
||||
if not results:
|
||||
raise UnknownNameError("No results to return")
|
||||
|
||||
|
|
@ -523,16 +722,35 @@ class Wallet(object):
|
|||
else:
|
||||
raise Exception(results['error'])
|
||||
|
||||
if 'certificate' in results:
|
||||
try:
|
||||
decoded = smart_decode(results['certificate']['value'])
|
||||
claim_dict = decoded.claim_dict
|
||||
outpoint = ClaimOutpoint(results['certificate']['txid'],
|
||||
results['certificate']['nout'])
|
||||
name = results['certificate']['name']
|
||||
results['certificate']['value'] = claim_dict
|
||||
results['certificate']['hex'] = decoded.serialized.encode('hex')
|
||||
if update_caches:
|
||||
yield self._save_name_metadata(name, outpoint, decoded.source_hash)
|
||||
yield self._update_claimid(results['certificate']['claim_id'], name, outpoint)
|
||||
yield self._storage.save_claim_to_cache(results['certificate']['claim_id'],
|
||||
results['certificate']['claim_sequence'],
|
||||
decoded, results['certificate']['address'],
|
||||
results['certificate']['height'],
|
||||
results['certificate']['amount'],
|
||||
results['certificate']['supports'],
|
||||
None,
|
||||
None)
|
||||
except DecodeError:
|
||||
pass
|
||||
|
||||
if 'claim' in results:
|
||||
claim = results['claim']
|
||||
if 'has_signature' in claim and claim['has_signature']:
|
||||
if not claim['signature_is_valid']:
|
||||
log.warning("lbry://%s#%s has an invalid signature",
|
||||
claim['name'], claim['claim_id'])
|
||||
decoded = ClaimDict.load_dict(claim['value'])
|
||||
claim_dict = decoded.claim_dict
|
||||
claim['value'] = claim_dict
|
||||
defer.returnValue(claim)
|
||||
try:
|
||||
decoded = smart_decode(claim['value'])
|
||||
claim_dict = decoded.claim_dict
|
||||
|
|
@ -540,24 +758,28 @@ class Wallet(object):
|
|||
name = claim['name']
|
||||
claim['value'] = claim_dict
|
||||
claim['hex'] = decoded.serialized.encode('hex')
|
||||
yield self._save_name_metadata(name, outpoint, decoded.source_hash)
|
||||
yield self._update_claimid(claim['claim_id'], name, outpoint)
|
||||
if update_caches:
|
||||
yield self._save_name_metadata(name, outpoint, decoded.source_hash)
|
||||
yield self._update_claimid(claim['claim_id'], name, outpoint)
|
||||
yield self._storage.save_claim_to_cache(claim['claim_id'],
|
||||
claim['claim_sequence'],
|
||||
decoded, claim['address'],
|
||||
claim['height'],
|
||||
claim['amount'], claim['supports'],
|
||||
claim.get('channel_name', None),
|
||||
claim.get('signature_is_valid', None))
|
||||
except DecodeError:
|
||||
claim['hex'] = claim['value']
|
||||
claim['value'] = None
|
||||
claim['error'] = "Failed to decode value"
|
||||
|
||||
results = claim
|
||||
results['claim'] = claim
|
||||
|
||||
elif 'value' in results:
|
||||
if 'has_signature' in results and results['has_signature']:
|
||||
if not results['signature_is_valid']:
|
||||
log.warning("lbry://%s#%s has an invalid signature",
|
||||
results['name'], results['claim_id'])
|
||||
decoded = ClaimDict.load_dict(results['value'])
|
||||
claim_dict = decoded.claim_dict
|
||||
results['value'] = claim_dict
|
||||
defer.returnValue(results)
|
||||
try:
|
||||
decoded = ClaimDict.load_dict(results['value'])
|
||||
claim_dict = decoded.claim_dict
|
||||
|
|
@ -565,8 +787,18 @@ class Wallet(object):
|
|||
claim_err = None
|
||||
outpoint = ClaimOutpoint(results['txid'], results['nout'])
|
||||
name = results['name']
|
||||
yield self._save_name_metadata(name, outpoint, decoded.source_hash)
|
||||
yield self._update_claimid(results['claim_id'], name, outpoint)
|
||||
if update_caches:
|
||||
yield self._save_name_metadata(name, outpoint, decoded.source_hash)
|
||||
yield self._update_claimid(results['claim_id'], name, outpoint)
|
||||
yield self._storage.save_claim_to_cache(results['claim_id'],
|
||||
results.get('claim_sequence', None),
|
||||
decoded, results['address'],
|
||||
results['height'], results['amount'],
|
||||
results.get('supports', '[]'),
|
||||
results.get('channel_name', None),
|
||||
results.get('signature_is_valid',
|
||||
None))
|
||||
|
||||
except DecodeError:
|
||||
claim_dict = None
|
||||
claim_hex = results['value']
|
||||
|
|
@ -576,33 +808,46 @@ class Wallet(object):
|
|||
results['hex'] = claim_hex
|
||||
results['value'] = claim_dict
|
||||
|
||||
log.info("get claim info lbry://%s#%s", results['name'], results['claim_id'])
|
||||
defer.returnValue(results)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def resolve_uri(self, uri):
|
||||
resolve_results = yield self._get_value_for_uri(uri)
|
||||
if 'claim' in resolve_results:
|
||||
formatted = yield self._handle_claim_result(resolve_results)
|
||||
resolve_results['claim'] = formatted
|
||||
result = resolve_results
|
||||
elif 'claims_in_channel' in resolve_results:
|
||||
claims_for_return = []
|
||||
for claim in resolve_results['claims_in_channel']:
|
||||
formatted = yield self._handle_claim_result(claim)
|
||||
claims_for_return.append(formatted)
|
||||
resolve_results['claims_in_channel'] = claims_for_return
|
||||
result = resolve_results
|
||||
elif 'error' in resolve_results:
|
||||
raise Exception(resolve_results['error'])
|
||||
def resolve_uri(self, uri, check_cache=True):
|
||||
cached_claim = None
|
||||
if check_cache:
|
||||
cached_claim = yield self._storage.get_cached_claim_for_uri(uri, check_cache)
|
||||
if cached_claim:
|
||||
log.debug("Using cached results for %s", uri)
|
||||
resolve_results = cached_claim
|
||||
else:
|
||||
result = None
|
||||
log.info("Resolving %s", uri)
|
||||
resolve_results = yield self._get_value_for_uri(uri)
|
||||
|
||||
claim_id = None
|
||||
if resolve_results and 'claim' in resolve_results:
|
||||
claim_id = resolve_results['claim']['claim_id']
|
||||
certificate_id = None
|
||||
if resolve_results and 'certificate' in resolve_results:
|
||||
certificate_id = resolve_results['certificate']['claim_id']
|
||||
|
||||
result = yield self._handle_claim_result(resolve_results, cached_claim is None)
|
||||
if claim_id:
|
||||
yield self._storage.save_claim_to_uri_cache(uri, claim_id, certificate_id)
|
||||
|
||||
defer.returnValue(result)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def get_claim_by_outpoint(self, claim_outpoint):
|
||||
claim = yield self._get_claim_by_outpoint(claim_outpoint['txid'], claim_outpoint['nout'])
|
||||
result = yield self._handle_claim_result(claim)
|
||||
def get_claim_by_outpoint(self, claim_outpoint, check_expire=True):
|
||||
claim_id = yield self._storage.get_claimid_for_tx(claim_outpoint)
|
||||
txid, nout = claim_outpoint['txid'], claim_outpoint['nout']
|
||||
if claim_id:
|
||||
cached_claim = yield self._storage.get_cached_claim(claim_id, check_expire)
|
||||
else:
|
||||
cached_claim = None
|
||||
if not cached_claim:
|
||||
claim = yield self._get_claim_by_outpoint(txid, nout)
|
||||
result = yield self._handle_claim_result(claim)
|
||||
else:
|
||||
result = cached_claim
|
||||
defer.returnValue(result)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
|
|
@ -1124,7 +1369,7 @@ class LBRYumWallet(Wallet):
|
|||
def _do_send_many(self, payments_to_send):
|
||||
def broadcast_send_many(paytomany_out):
|
||||
if 'hex' not in paytomany_out:
|
||||
raise Exception('Unepxected paytomany output:{}'.format(paytomany_out))
|
||||
raise Exception('Unexpected paytomany output:{}'.format(paytomany_out))
|
||||
return self._broadcast_transaction(paytomany_out['hex'])
|
||||
|
||||
log.debug("Doing send many. payments to send: %s", str(payments_to_send))
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ class ManagedEncryptedFileDownloader(EncryptedFileSaver):
|
|||
self.outpoint = ClaimOutpoint(self.txid, self.nout)
|
||||
else:
|
||||
raise NoSuchSDHash(self.sd_hash)
|
||||
self.claim_id = yield self.wallet.get_claimid(self.name, self.txid, self.nout)
|
||||
self.claim_id = yield self.wallet.get_claimid(self.txid, self.nout)
|
||||
defer.returnValue(None)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
|
|
|
|||
|
|
@ -878,7 +878,7 @@ class Daemon(AuthJSONRPCServer):
|
|||
size = None
|
||||
message = None
|
||||
|
||||
claim = yield self.session.wallet.get_claim(lbry_file.claim_id)
|
||||
claim = yield self.session.wallet.get_claim(lbry_file.claim_id, check_expire=False)
|
||||
|
||||
if claim and 'value' in claim:
|
||||
metadata = claim['value']
|
||||
|
|
@ -915,7 +915,6 @@ class Daemon(AuthJSONRPCServer):
|
|||
'suggested_file_name': lbry_file.suggested_file_name,
|
||||
'sd_hash': lbry_file.sd_hash,
|
||||
'name': lbry_file.name,
|
||||
'channel_name': channel_name,
|
||||
'outpoint': outpoint,
|
||||
'claim_id': lbry_file.claim_id,
|
||||
'download_path': full_path,
|
||||
|
|
@ -926,6 +925,8 @@ class Daemon(AuthJSONRPCServer):
|
|||
'message': message,
|
||||
'metadata': metadata
|
||||
}
|
||||
if channel_name is not None:
|
||||
result['channel_name'] = channel_name
|
||||
if has_signature is not None:
|
||||
result['has_signature'] = has_signature
|
||||
if signature_is_valid is not None:
|
||||
|
|
@ -1394,7 +1395,13 @@ class Daemon(AuthJSONRPCServer):
|
|||
}
|
||||
"""
|
||||
try:
|
||||
claim_results = yield self.session.wallet.get_claim_info(name, txid, nout, claim_id)
|
||||
if claim_id:
|
||||
claim_results = yield self.session.wallet.get_claim(claim_id)
|
||||
elif txid and nout is not None:
|
||||
outpoint = ClaimOutpoint(txid, nout)
|
||||
claim_results = yield self.session.wallet.get_claim_by_outpoint(outpoint)
|
||||
else:
|
||||
claim_results = yield self.session.wallet.get_claim_by_name(name)
|
||||
result = format_json_out_amount_as_float(claim_results)
|
||||
except (TypeError, UnknownNameError):
|
||||
result = False
|
||||
|
|
|
|||
Loading…
Reference in a new issue