def __init__(self, base_url, keyfile=None):
self._base_url = base_url
if keyfile is None:
self._signer = None
return
try:
with open(keyfile) as fd:
private_key_str = fd.read().strip()
except OSError as err:
raise XoException('Failed to read private key {}: {}'.format(
keyfile, str(err)))
try:
private_key = Secp256k1PrivateKey.from_hex(private_key_str)
except ParseError:
try:
private_key = Secp256k1PrivateKey.from_wif(private_key_str)
except ParseError as e:
raise XoException('Unable to load private key: {}'.format(
str(e)))
self._signer = CryptoFactory(create_context('secp256k1')) \
.new_signer(private_key)
def _send_request(
self, suffix, data=None,
content_type=None, name=None, auth_user=None, auth_password=None):
if self._base_url.startswith("http://"):
url = "{}/{}".format(self._base_url, suffix)
else:
url = "http://{}/{}".format(self._base_url, suffix)
headers = {}
if auth_user is not None:
auth_string = "{}:{}".format(auth_user, auth_password)
b64_string = b64encode(auth_string.encode()).decode()
auth_header = 'Basic {}'.format(b64_string)
headers['Authorization'] = auth_header
if content_type is not None:
headers['Content-Type'] = content_type
try:
if data is not None:
result = requests.post(url, headers=headers, data=data)
else:
result = requests.get(url, headers=headers)
if result.status_code == 404:
raise XoException("No such game: {}".format(name))
elif not result.ok:
raise XoException("Error {}: {}".format(
result.status_code, result.reason))
except BaseException as err:
raise XoException(err)
return result.text
def _send_request(self, suffix, data=None, content_type=None, name=None):
if self._base_url.startswith("http://"):
url = "{}/{}".format(self._base_url, suffix)
else:
url = "http://{}/{}".format(self._base_url, suffix)
headers = {}
if content_type is not None:
headers['Content-Type'] = content_type
try:
if data is not None:
result = requests.post(url, headers=headers, data=data)
else:
result = requests.get(url, headers=headers)
if result.status_code == 404:
raise XoException("No such item: {}".format(name))
elif not result.ok:
raise XoException("Error {}:{}".format(result.status_code,
result.reason))
except requests.ConnectionError as err:
raise XoException('Failed to connect to {}:{}'.format(
url, str(err)))
except BaseException as err:
raise XoException(err)
return result.text
def main(prog_name=os.path.basename(sys.argv[0]), args=None):
if args is None:
args = sys.argv[1:]
parser = create_parser(prog_name)
args = parser.parse_args(args)
if args.verbose is None:
verbose_level = 0
else:
verbose_level = args.verbose
setup_loggers(verbose_level=verbose_level)
if args.command == 'create':
do_create(args)
elif args.command == 'list':
do_list(args)
elif args.command == 'show':
do_show(args)
elif args.command == 'take':
do_take(args)
elif args.command == 'delete':
do_delete(args)
else:
raise XoException("invalid command: {}".format(args.command))
def main(prog_name=os.path.basename(sys.argv[0]), args=sys.argv[1:]):
parser = create_parser(prog_name)
args = parser.parse_args(args)
if args.verbose is None:
verbose_level = 0
else:
verbose_level = args.verbose
setup_loggers(verbose_level=verbose_level)
config = load_config()
if args.command == 'create':
do_create(args, config)
elif args.command == 'init':
do_init(args, config)
elif args.command == 'reset':
do_reset(args, config)
elif args.command == 'list':
do_list(args, config)
elif args.command == 'show':
do_show(args, config)
elif args.command == 'take':
do_take(args, config)
else:
raise XoException("invalid command: {}".format(args.command))
def do_show(args, config):
name = args.name
url = config.get('DEFAULT', 'url')
key_file = config.get('DEFAULT', 'key_file')
client = XoClient(base_url=url, keyfile=key_file)
game = client.show(name).decode()
if game is not None:
board_str, game_state, player1, player2, name = \
game.split(",")
board = list(board_str.replace("-", " "))
print("GAME: : {}".format(name))
print("PLAYER 1 : {}".format(player1[:6]))
print("PLAYER 2 : {}".format(player2[:6]))
print("STATE : {}".format(game_state))
print("")
print(" {} | {} | {}".format(board[0], board[1], board[2]))
print(" ---|---|---")
print(" {} | {} | {}".format(board[3], board[4], board[5]))
print(" ---|---|---")
print(" {} | {} | {}".format(board[6], board[7], board[8]))
print("")
else:
raise XoException("Game not found: {}".format(name))
def __init__(self, base_url, keyfile):
self._base_url = base_url
try:
with open(keyfile) as fd:
self._private_key = fd.read().strip()
fd.close()
except FileNotFoundError:
raise XoException(
'Could not find private key file {}; '
'try running `sawtooth keygen`'.format(keyfile))
except OSError:
raise XoException("Failed to read keys.")
self._public_key = signing.generate_pubkey(self._private_key)
def _get_status(self, batch_id, wait):
try:
result = self._send_request('batch_statuses?id={}&wait={}'.format(
batch_id, wait))
return yaml.safe_load(result)['data'][0]['status']
except BaseException as err:
raise XoException(err)
def do_show(args):
name = args.name
url = _get_url(args)
keyfile = _get_keyfile(args)
auth_user, auth_password = _get_auth_info(args)
client = XoClient(base_url=url, keyfile=keyfile)
data = client.show(name, auth_user=auth_user, auth_password=auth_password)
if data is not None:
board_str, game_state, player1, player2 = {
name: (board, state, player_1, player_2)
for name, board, state, player_1, player_2 in
[game.split(',') for game in data.decode().split('|')]
}[name]
board = list(board_str.replace("-", " "))
print("GAME: : {}".format(name))
print("PLAYER 1 : {}".format(player1[:6]))
print("PLAYER 2 : {}".format(player2[:6]))
print("STATE : {}".format(game_state))
print("")
print(" {} | {} | {}".format(board[0], board[1], board[2]))
print(" ---|---|---")
print(" {} | {} | {}".format(board[3], board[4], board[5]))
print(" ---|---|---")
print(" {} | {} | {}".format(board[6], board[7], board[8]))
print("")
else:
raise XoException("Game not found: {}".format(name))
def do_show(args, config):
name = args.name
url = config.get('DEFAULT', 'url')
key_file = config.get('DEFAULT', 'key_file')
client = XoClient(base_url=url, keyfile=key_file)
state = client.get_state()
if name not in state:
raise XoException('no such game: {}'.format(name))
game = state[name]
player1 = ''
player2 = ''
if 'Player1' in game:
player1 = game['Player1']
if 'Player2' in game:
player2 = game['Player2']
board = list(game['Board'].replace('-', ' '))
game_state = game['State']
print "GAME: : {}".format(name)
print "PLAYER 1 : {}".format(player1)
print "PLAYER 2 : {}".format(player2)
print "STATE : {}".format(game_state)
print ""
print " {} | {} | {}".format(board[0], board[1], board[2])
print " ---|---|---"
print " {} | {} | {}".format(board[3], board[4], board[5])
print " ---|---|---"
print " {} | {} | {}".format(board[6], board[7], board[8])
print ""
def _get_status(self, batch_id, wait, auth_user=None, auth_password=None):
try:
result = self._send_request('batch_status?id={}&wait={}'.format(
batch_id, wait),
auth_user=auth_user,
auth_password=auth_password)
return yaml.safe_load(result)['data'][0]['status']
except BaseException as err:
raise XoException(err)
def _send_request(self, suffix, data=None, content_type=None):
url = "http://{}/{}".format(self._base_url, suffix)
headers = None
if content_type is not None:
headers = {'Content-Type': content_type}
try:
if data is not None:
result = requests.post(url, headers=headers, data=data)
else:
result = requests.get(url)
if not result.ok:
raise XoException("Error {}: {}".format(
result.status_code, result.reason))
except BaseException as err:
raise XoException(err)
return result.text
def _send_request(self, suffix, content=None, content_type=None):
url = "http://{}/{}".format(self._base_url, suffix)
if content_type is not None:
content_type = {'Content-Type': content_type}
if content is None or content_type is None:
request = urllib.request.Request(url)
else:
request = urllib.request.Request(url, content, content_type)
try:
result = urllib.request.urlopen(request).read().decode()
except BaseException as err:
raise XoException(err)
return result
def __init__(self, base_url, keyfile=None):
self._base_url = base_url
if keyfile is None:
self._private_key = None
self._public_key = None
return
try:
with open(keyfile) as fd:
self._private_key = fd.read().strip()
fd.close()
except OSError as err:
raise XoException('Failed to read private key {}: {}'.format(
keyfile, str(err)))
self._public_key = signing.generate_public_key(self._private_key)
def do_list(args, config):
url = config.get('DEFAULT', 'url')
key_file = config.get('DEFAULT', 'key_file')
client = XoClient(base_url=url, keyfile=key_file)
game_list = client.list()
if game_list is not None:
fmt = "%-15s %-15.15s %-15.15s %-9s %s"
print(fmt % ('GAME', 'PLAYER 1', 'PLAYER 2', 'BOARD', 'STATE'))
for game_data in game_list:
board, game_state, player1, player2, name = \
game_data.decode().split(",")
print(fmt % (name, player1[:6], player2[:6], board, game_state))
else:
raise XoException("Could not retrieve game listing.")
def do_init(args, config):
username = config.get('DEFAULT', 'username')
if args.username is not None:
username = args.username
url = config.get('DEFAULT', 'url')
if args.url is not None:
url = args.url
config.set('DEFAULT', 'username', username)
print("set username: {}".format(username))
config.set('DEFAULT', 'url', url)
print("set url: {}".format(url))
save_config(config)
wif_filename = config.get('DEFAULT', 'key_file')
if wif_filename.endswith(".wif"):
addr_filename = wif_filename[0:-len(".wif")] + ".addr"
else:
addr_filename = wif_filename + ".addr"
if not os.path.exists(wif_filename):
try:
if not os.path.exists(os.path.dirname(wif_filename)):
os.makedirs(os.path.dirname(wif_filename))
privkey = signing.generate_privkey()
encoded = signing.encode_privkey(privkey, 'wif')
pubkey = signing.generate_pubkey(privkey)
addr = signing.generate_identifier(pubkey)
with open(wif_filename, "w") as wif_fd:
print("writing file: {}".format(wif_filename))
wif_fd.write(encoded)
wif_fd.write("\n")
with open(addr_filename, "w") as addr_fd:
print("writing file: {}".format(addr_filename))
addr_fd.write(addr)
addr_fd.write("\n")
except IOError as ioe:
raise XoException("IOError: {}".format(str(ioe)))
def do_list(args):
url = _get_url(args)
auth_user, auth_password = _get_auth_info(args)
client = XoClient(base_url=url, keyfile=None)
game_list = [
game.split(',') for games in client.list(auth_user=auth_user,
auth_password=auth_password)
for game in games.decode().split('|')
]
if game_list is not None:
fmt = "%-15s %-15.15s %-15.15s %-9s %s"
print(fmt % ('GAME', 'PLAYER 1', 'PLAYER 2', 'BOARD', 'STATE'))
for game_data in game_list:
name, board, game_state, player1, player2 = game_data
print(fmt % (name, player1[:6], player2[:6], board, game_state))
else:
raise XoException("Could not retrieve game listing.")
def do_init(args, config):
username = config.get('DEFAULT', 'username')
if args.username is not None:
username = args.username
config.set('DEFAULT', 'username', username)
print "set username: {}".format(username)
save_config(config)
wif_filename = config.get('DEFAULT', 'key_file')
if wif_filename.endswith(".wif"):
addr_filename = wif_filename[0:-len(".wif")] + ".addr"
else:
addr_filename = wif_filename + ".addr"
if not os.path.exists(wif_filename):
try:
if not os.path.exists(os.path.dirname(wif_filename)):
os.makedirs(os.path.dirname(wif_filename))
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
with open(wif_filename, "w") as wif_fd:
print "writing file: {}".format(wif_filename)
wif_fd.write(encoded)
wif_fd.write("\n")
with open(addr_filename, "w") as addr_fd:
print "writing file: {}".format(addr_filename)
addr_fd.write(addr)
addr_fd.write("\n")
except IOError, ioe:
raise XoException("IOError: {}".format(str(ioe)))
def _get_merkle_root(self):
result = self._send_request("state")
try:
return yaml.load(result)['merkleRoot']
except BaseException:
raise XoException("Could not retrieve merkle root.")
def check_valid(self, store):
"""Determines if the transaction is valid.
Args:
store (dict): Transaction store mapping.
"""
if not super(XoTransaction, self).is_valid(store):
raise XoException("invalid transaction")
LOGGER.debug('checking %s', str(self))
if self._name is None or self._name == '':
raise XoException('name not set')
if self._action is None or self._action == '':
raise XoException('action not set')
if self._action == 'CREATE':
if self._name in store:
raise XoException('game already exists')
elif self._action == 'TAKE':
if self._space is None:
raise XoException('TAKE requires space')
if self._space < 1 or self._space > 9:
raise XoException('invalid space')
if self._name not in store:
raise XoException('no such game')
state = store[self._name]['State']
if state in ['P1-WIN', 'P2-WIN', 'TIE']:
raise XoException('game complete')
if state == 'P1-NEXT' and 'Player1' in store[self._name]:
player1 = store[self._name]['Player1']
if player1 != self.OriginatorID:
raise XoException('invalid player 1')
if state == 'P2-NEXT' and 'Player2' in store[self._name]:
player1 = store[self._name]['Player2']
if player1 != self.OriginatorID:
raise XoException('invalid player 2')
if store[self._name]['Board'][self._space - 1] != '-':
raise XoException('space already taken')
else:
raise XoException('invalid action')