def __init__(self):
self.__logger = get_logger('RPCServer')
self.runner = None
self.site = None
# define our RPCs
self.__RPCs = {}
self.app = web.Application()
self.app.add_routes([
web.post('/', self.__http_proccess),
web.get('/status', self.get_status)
])
# self.app.on_shutdown.append(self.stop_server)
# FIXME !!!!! MUST be removed before release -->
self.add_callback("PING_REQ", "PING_RESP", self.__receive_rpc_ping)
self.add_callback("SQL_REQ", "SQL_RESP", self.__receive_rpc_sql)
# <--
self.add_callback("FETCHCHUNK_REQ", "FETCHCHUNK_RESP",
receive_rpc_fetchchunk)
self.add_callback("IMAGEDOWNLOAD_REQ", "IMAGEDOWNLOAD_RESP",
receive_rpc_download_image)
self.add_callback("THUMBNAIL_DOWNLOAD_REQ", "THUMBNAIL_DOWNLOAD_RESP",
receive_rpc_download_thumbnail)
def __init__(self,
user,
password,
ip,
rpcport,
pastelid=None,
passphrase=None):
self.url = "http://%s:%s@%s:%s" % (user, password, ip, rpcport)
self.__reconnect()
self.__logger = get_logger('BlockChain')
# passing `passphrase` parameter has the same idea as `pastelid` one.
# we pass it for wallet_api and leave blank for masternode
if not passphrase:
self.passphrase = Settings.PASTEL_ID_PASSPHRASE
else:
self.passphrase = passphrase
# for masternode mode - pastelID should be empty and fetched automatically
# for wallet API mode - user will change which pastelID use, so wallet_api will create Blockchain object with
# predefined pastelid
if not pastelid:
self.pastelid = self.get_pastel_id()
else:
self.pastelid = pastelid
def __init__(self, pastelid, passphrase):
self.__logger = get_logger('Wallet interface')
self.pastelid = pastelid
self.passphrase = passphrase
self.__active_tasks = {}
def __init__(self):
# initialize logging
self.__logger = get_logger('Masternode Daemon')
self.rpcserver = RPCServer()
for rpc_handler in RPC_HANDLER_LIST:
self.rpcserver.add_callback(*rpc_handler)
self.__logger.debug("Art Registration callback handlers set")
self.__logger.debug("Masternode Daemon initialized")
def __init__(self, remote_pastelid, server_ip, server_port):
self.__logger = get_logger('RPC Client')
if not remote_pastelid:
raise ValueError('Remove pastelid cannot be empty')
if not server_ip:
raise ValueError('IP address cannot be empty')
if not server_port:
raise ValueError('Port cannot be empty')
# variables of the server (the MN)
self.__server_ip = server_ip
self.server_ip = server_ip
self.__server_port = server_port
self.remote_pastelid = remote_pastelid
self.__name = ''
self.__reputation = None
def __init__(self):
# initialize logger
# IMPORTANT: we must ALWAYS use self.__logger.* for logging and not logging.*,
# since we need instance-level logging
self.__logger = get_logger('Chunk Manager')
# the actual storage layer
self.__logger.debug("Setting ChunkStorage at %s" %
Settings.CHUNK_DATA_DIR)
self.__storage = ChunkStorage(Settings.CHUNK_DATA_DIR, mode=0o0700)
# tmp storage
self.__logger.debug("Setting TmpStorage at %s" %
Settings.TEMP_STORAGE_DIR)
self.__tmpstorage = ChunkStorage(Settings.TEMP_STORAGE_DIR,
mode=0o0700)
self.__logger.debug("Chunk Manager initialized")
from datetime import datetime
from peewee import DoesNotExist
from core_modules.blackbox_modules.nsfw import get_nsfw_detector
from core_modules.chunkmanager import get_chunkmanager
from core_modules.database import Regticket, MASTERNODE_DB, Chunk
from utils.mn_ordering import get_masternode_ordering
from cnode_connection import get_blockchain_connection
from .ticket_models import RegistrationTicket, Signature, ImageData
from core_modules.helpers import require_true, bytes_to_chunkid
from core_modules.logger import get_logger
mn_ticket_logger = get_logger('Ticket Manager')
async def is_burn_10_tx_height_valid(regticket, txid):
regticket = RegistrationTicket(serialized=regticket.regticket)
sleep_counter = 0
while True:
try:
raw_tx_data = get_blockchain_connection().getrawtransaction(
txid, verbose=1)
break
except Exception as ex:
await asyncio.sleep(5)
if sleep_counter > 10:
raise ex
from aiohttp import ClientConnectorError, ServerTimeoutError
from bitcoinrpc.authproxy import JSONRPCException
from peewee import DoesNotExist, IntegrityError
from core_modules.database import Masternode, Chunk, ChunkMnDistance, ChunkMnRanked, MASTERNODE_DB, \
ActivationTicket
from core_modules.logger import get_logger
from core_modules.chunkmanager import get_chunkmanager
from core_modules.ticket_models import RegistrationTicket
from core_modules.rpc_client import RPCException
from core_modules.settings import Settings
from core_modules.helpers import get_pynode_digest_int, chunkid_to_hex
from cnode_connection import get_blockchain_connection
tasks_logger = get_logger('Tasks')
chunk_storage_logger = get_logger('ChunkStorage')
TXID_LENGTH = 64
def update_masternode_list():
"""
Fetch current masternode list from cNode (by calling `masternode list extra`) and
update database Masternode table accordingly.
Return 2 sets of MN pastelIDs - added and removed,
"""
masternode_list = get_blockchain_connection().masternode_list()
# parse new list
fresh_mn_list = {}
import asyncio
from datetime import datetime
from cnode_connection import get_blockchain_connection
from core_modules.ticket_models import RegistrationTicket, Signature, ImageData
from core_modules.logger import get_logger
from utils.mn_ordering import get_masternode_ordering
from wallet.database import RegticketDB
art_reg_client_logger = get_logger('Art Registration')
class ArtRegistrationClient:
@classmethod
def generate_signed_ticket(cls, ticket):
signed_ticket = Signature(
dictionary={
"signature":
get_blockchain_connection().pastelid_sign(
ticket.serialize_base64()),
"pastelid":
get_blockchain_connection().pastelid
})
# make sure we validate correctly
signed_ticket.validate(ticket)
return signed_ticket
@classmethod
def generate_regticket(cls, image_data: bytes, regticket_data: dict):
image = ImageData(
import msgpack
from PIL import Image
from cnode_connection import get_blockchain_connection
from core_modules.helpers import get_pynode_digest_bytes, require_true
from core_modules.logger import get_logger
from core_modules.model_validators import FieldValidator, StringField, IntegerField, FingerprintField, SHA3512Field, \
LubyChunkHashField, LubyChunkField, ImageField, ThumbnailField, TXIDField, SignatureField, \
PastelIDField, LubySeedField
from core_modules.settings import Settings
from core_modules.helpers import bytes_to_hex
from core_modules.blackbox_modules import luby
ticket_logger = get_logger('Tickets')
def get_block_distance(atxid, btxid):
if type(atxid) == bytes:
atxid = bytes_to_hex(atxid)
if type(btxid) == bytes:
btxid = bytes_to_hex(btxid)
block_a = get_blockchain_connection().getblock(atxid)
block_b = get_blockchain_connection().getblock(btxid)
height_a = int(block_a["height"])
height_b = int(block_b["height"])
return abs(height_a - height_b)
Image chunking algorithms (generate chunks, reconstruct image).
"""
import hashlib
import struct
import random
import math
from struct import pack, unpack
from collections import defaultdict
from core_modules.logger import get_logger
HEADER_PATTERN = '<3I32s'
HEADER_LENGTH = struct.calcsize(HEADER_PATTERN)
luby_logger = get_logger('Lubby')
class NotEnoughChunks(Exception):
pass
class BlockParseError(Exception):
pass
# LT Coding Helper fucntions:
class _PRNG:
"""
A Pseudorandom Number Generator that yields samples from the set of source
blocks using the RSD degree distribution described above.
"""
This file contains some RPC method handlers' implementaetion (pynode to pynode endpoints).
"""
import peewee
from core_modules.blackbox_modules import luby
from core_modules.chunkmanager import get_chunkmanager
from core_modules.database import Chunk, ChunkMnRanked, Masternode
from core_modules.helpers import hex_to_chunkid
from core_modules.logger import get_logger
rpc_handler_logger = get_logger('RPC Handler')
def receive_rpc_fetchchunk(data, **kwargs):
if not isinstance(data, dict):
raise TypeError("Data must be a dict!")
if set(data.keys()) != {"chunkid"}:
raise ValueError("Invalid arguments for spotcheck: %s" % (data.keys()))
if not isinstance(data["chunkid"], str):
raise TypeError("Invalid type for key chunkid in spotcheck")
chunkid = hex_to_chunkid(
data["chunkid"]) # here chunkid is long integer number
# fetch chunk from DB, check if we store it
try:
chunk = Chunk.get(chunk_id=str(chunkid))
"""
Connection client for pasteld http API.
"""
import os
import time
import bitcoinrpc
from core_modules.blockchain import BlockChain
from core_modules.logger import get_logger
from core_modules.settings import Settings
cnode_connection_logger = get_logger("cNode Connection")
# global blockchain connection object, used for cNode communication
_blockchain = None
def connect_to_blockchain_daemon():
pastelid = os.environ.get('PASTEL_ID')
passphrase = os.environ.get('PASSPHRASE')
cnode_connection_logger.debug(
"Connecting to cNode at %s:%s as %s..." %
(Settings.CNODE_RPC_IP, Settings.CNODE_RPC_PORT,
Settings.CNODE_RPC_USER))
while True:
if pastelid and passphrase: # running a wallet
blockchain = BlockChain(Settings.CNODE_RPC_USER,
Settings.CNODE_RPC_PWD,
Settings.CNODE_RPC_IP,
Settings.CNODE_RPC_PORT,