def setup(args):
"""
This method should only be called once and is responsible for the initial setup of the PlebNet
agent. All necessary configuration files are created and IRC communication is started.
:param args: If running in Testnet mode.
"""
global qtable, config
logger.log("Setting up PlebNet")
# Set general info about the PlebNet agent
settings.irc_nick(settings.irc_nick_def() +
str(random.randint(1000, 10000)))
config = PlebNetConfig()
config.set('expiration_date', time.time() + TIME_ALIVE)
# Prepare the QTable configuration
qtable = QTable()
if args.test_net:
settings.wallets_testnet("1")
qtable.read_dictionary({
'proxhost':
cloudomate_controller.get_vps_providers()['proxhost']
})
else:
providers = cloudomate_controller.get_vps_providers()
if providers.has_key('proxhost'):
del providers["proxhost"]
# Create QTable if it does not exist
qtable.read_dictionary(providers)
if args.exit_node:
logger.log("Running as exitnode")
settings.tribler_exitnode('1')
settings.settings.write()
# Prepare first child configuration
fake_generator.generate_child_account()
# Prepare the IRC Client
irc_handler.init_irc_client()
irc_handler.start_irc_client()
config.save()
# add learning_consumer as a consumer for qtable channel in addressbook
qtable.address_book.receiver.register_consumer("qtable", learning_consumer)
logger.success("PlebNet is ready to roll!")
def setup(args):
"""
This method should only be called once and is responsible for the initial setup of the PlebNet
agent. All necessary configuration files are created and IRC communication is started.
:param args: If running in Testnet mode.
"""
global dna, config
logger.log("Setting up PlebNet")
# Prepare the DNA configuration
dna = DNA()
if args.test_net:
settings.wallets_testnet("1")
settings.settings.write()
dna.read_dictionary({
'proxhost':
cloudomate_controller.get_vps_providers()['proxhost']
})
else:
dna.read_dictionary(cloudomate_controller.get_vps_providers())
if 'proxhost' in dna.vps.keys():
dna.remove_provider('proxhost')
dna.write_dictionary()
if args.exit_node:
logger.log("Running as exitnode")
settings.tribler_exitnode('1')
# Prepare first child configuration
fake_generator.generate_child_account()
# Set general info about the PlebNet agent
settings.irc_nick(settings.irc_nick_def() +
str(random.randint(1000, 10000)))
config = PlebNetConfig()
config.set('expiration_date',
time.time() + 30 * plebnet_settings.TIME_IN_DAY)
# Prepare the IRC Client
irc_handler.init_irc_client()
irc_handler.start_irc_client()
if dna.get_own_tree() == '':
logger.log("tree set to %s" % settings.irc_nick())
dna.set_own_tree(settings.irc_nick())
config.save()
logger.success("PlebNet is ready to roll!")
def setup(args):
logger.log("Setting up PlebNet")
# Prepare Cloudomate
if args.test_net:
settings.wallets_testnet("1")
settings.settings.write()
fake_generator.generate_child_account()
# TODO: change --> Prepare plebnet
config = PlebNetConfig()
config.set('expiration_date',
time.time() + 30 * plebnet_settings.TIME_IN_DAY)
config.save()
# handle the DNA
dna = DNA()
dna.read_dictionary(cloudomate_controller.get_vps_providers())
dna.write_dictionary()
# Prepare the IRC Client
irc_handler.init_irc_client()
irc_handler.start_irc_client()
logger.success("PlebNet is ready to roll!")
def test_pick_providers(self, mock1):
self.vps = cloudomate.get_vps_providers
self.get_gateway = blueAngel.BlueAngelHost.get_gateway
self.estimate_price = Coinbase.Coinbase.estimate_price
self.get_price = wallet_util.get_price
self.get_fee = wallet_util.get_network_fee
# cloudomate.get_vps_providers = MagicMock(
# return_value=CaseInsensitiveDict({'blueangelhost': blueAngel.BlueAngelHost}))
random.expovariate = MagicMock(return_value=0.55)
blueAngel.BlueAngelHost.get_gateway = MagicMock()
Coinbase.Coinbase.estimate_price = MagicMock()
cloudomate.pick_option = MagicMock(return_value=[1, 2, 3])
wallet_util.get_price = MagicMock()
wallet_util.get_network_fee = MagicMock()
cloudomate.pick_provider(cloudomate.get_vps_providers())
blueAngel.BlueAngelHost.get_gateway.assert_called_once()
cloudomate.get_vps_providers = self.vps
blueAngel.BlueAngelHost.get_gateway = self.get_gateway
Coinbase.Coinbase.estimate_price = self.estimate_price
wallet_util.get_price = self.get_price
wallet_util.get_network_fee = self.get_fee
def attempt_purchase():
"""
Check if enough money to buy a server, and if so, do so,
"""
(provider, option, _) = config.get('chosen_provider')
if settings.wallets_testnet():
domain = 'TBTC'
else:
domain = 'BTC'
if market_controller.get_balance(domain) >= (
cloudomate_controller.calculate_price(provider, option) +
cloudomate_controller.calculate_price_vpn()):
logger.log("Try to buy a new server from %s" % provider, log_name)
success = cloudomate_controller.purchase_choice(config)
if success == plebnet_settings.SUCCESS:
# Evolve yourself positively if you are successful
dna.evolve(True)
logger.log(
"Purchasing vps for child %s successful" %
(dna.get_own_tree() + '.' + str(config.get('child_index'))))
# purchase VPN with same config if server allows for it
if cloudomate_controller.get_vps_providers(
)[provider].TUN_TAP_SETTINGS:
attempt_purchase_vpn()
elif success == plebnet_settings.FAILURE:
# Evolve provider negatively if not successful
dna.evolve(False, provider)
config.increment_child_index()
fake_generator.generate_child_account()
config.set('chosen_provider', None)
config.save()
def install_available_servers(config, dna):
"""
This function checks if there are any servers ready to be installed and installs PlebNet on them.
:param config: The configuration of this Plebbot
:type config: dict
:param dna: The DNA of this Plebbot
:type dna: DNA
:return: None
:rtype: None
"""
bought = config.get('bought')
logger.log("install: %s" % bought, "install_available_servers")
for provider, transaction_hash, child_index in list(bought):
try:
provider_class = cloudomate_controller.get_vps_providers(
)[provider]
ip = cloudomate_controller.get_ip(provider_class)
except BaseException as e:
logger.log(
str(e) + "%s not ready yet" % provider,
"install_available_servers")
return
logger.log("Installing child on %s with ip %s" % (provider, ip))
if is_valid_ip(ip):
account_settings = cloudomate_controller.child_account(child_index)
parentname = '{0}-{1}'.format(
account_settings.get('user', 'firstname'),
account_settings.get('user', 'lastname'))
dna.create_child_dna(provider, parentname, transaction_hash)
# Save config before entering possibly long lasting process
config.save()
rootpw = account_settings.get('server', 'root_password')
success = _install_server(ip, rootpw)
# Reload config in case install takes a long time
config.load()
config.get('installed').append({provider: success})
if [provider, transaction_hash,
child_index] in config.get('bought'):
config.get('bought').remove(
[provider, transaction_hash, child_index])
config.save()
def attempt_purchase():
"""
Check if enough money to buy a server, and if so, do so,
"""
(provider, option, _) = config.get('chosen_provider')
provider_offer_ID = str(provider).lower() + "_" + str(option).lower()
if settings.wallets_testnet():
domain = 'TBTC'
else:
domain = 'BTC'
btc_balance = satoshi_to_btc(market_controller.get_balance(domain))
vps_price = cloudomate_controller.calculate_price(provider, option)
vpn_price = cloudomate_controller.calculate_price_vpn()
logger.log('Selected VPS: %s (%s), %s BTC' % (provider, option, vps_price),
log_name)
logger.log('Selected VPN: %s, %s BTC' % ("mullvad", vpn_price), log_name)
logger.log("Balance: %s %s" % (btc_balance, domain), log_name)
if btc_balance >= vps_price + vpn_price:
logger.log(
"Before trying to purchase VPS share current QTable with other agents"
)
qtable.share_qtable()
logger.log("Try to buy a new server from %s" % provider, log_name)
success = cloudomate_controller.purchase_choice(config)
if success == plebnet_settings.SUCCESS:
# Update qtable yourself positively if you are successful
qtable.update_qtable(remote_tables, provider_offer_ID, True,
get_reward_qlearning())
# purchase VPN with same config if server allows for it
# purchase VPN with same config if server allows for it
if cloudomate_controller.get_vps_providers(
)[provider].TUN_TAP_SETTINGS:
attempt_purchase_vpn()
elif success == plebnet_settings.FAILURE:
# Update qtable provider negatively if not successful
qtable.update_qtable(remote_tables, provider_offer_ID, False,
get_reward_qlearning())
qtable.write_dictionary()
config.increment_child_index()
fake_generator.generate_child_account()
config.set('chosen_provider', None)
config.save()
def select_provider():
"""
Check whether a provider is already selected, otherwise select one based on the Qtable.
"""
if not config.get('chosen_provider'):
logger.log("No provider chosen yet", log_name)
all_providers = cloudomate_controller.get_vps_providers()
excluded_providers = config.get('excluded_providers')
available_providers = list(
set(all_providers.keys()) - set(excluded_providers))
providers = {
k: all_providers[k]
for k in all_providers.keys() if k in available_providers
}
if len(providers) >= 1:
choice = cloudomate_controller.pick_provider(providers)
config.set('chosen_provider', choice)
logger.log("Provider chosen: %s" % str(config.get('chosen_provider')),
log_name)
config.save()
def install_available_servers(config, qtable):
"""
This function checks if any of the bought servers are ready to be installed and installs
PlebNet on them.
:param config: The configuration of this Plebbot
:type config: dict
:param qtable: The qtable of this Plebbot
:type qtable: QTable
:return: None
:rtype: None
"""
bought = config.get('bought')
logger.log("install: %s" % bought, "install_available_servers")
for bought_item in list(bought):
[provider, option, transaction_hash, child_index] = bought_item
# skip vpn providers as they show up as 'bought' as well
if provider in cloudomate_controller.get_vpn_providers():
continue
try:
provider_class = cloudomate_controller.get_vps_providers()[provider]
ip = cloudomate_controller.get_ip(provider_class, cloudomate_controller.child_account(child_index))
except Exception as e:
logger.log(str(e) + "%s not ready yet" % str(provider), "install_available_servers")
continue
if is_valid_ip(ip):
# VPN configuration, enable tun/tap settings
if provider_class.TUN_TAP_SETTINGS:
tun_success = provider_class(cloudomate_controller.child_account(child_index)).enable_tun_tap()
logger.log("Enabling %s tun/tap: %s"%(provider, tun_success))
if not cloudomate_controller.save_info_vpn(child_index):
logger.log("VPN not ready yet, can't save ovpn config")
# continue
logger.log("Installing child #%s on %s with ip %s" % (child_index, provider, str(ip)))
account_settings = cloudomate_controller.child_account(child_index)
rootpw = account_settings.get('server', 'root_password')
try:
provider_class(cloudomate_controller.child_account(child_index)).change_root_password(rootpw)
except Exception as e:
logger.error("Cannot change root password: %s" % str(e), "install_available_servers")
continue
time.sleep(5)
qtable.create_child_qtable(provider, option, transaction_hash, child_index)
# Save config before entering possibly long lasting process
config.get('bought').remove(bought_item)
config.get('installing').append(bought_item)
config.save()
success = _install_server(ip, rootpw, child_index, setup.get_instance().wallets_testnet())
# Reload config in case install takes a long time
config.load()
config.get('installing').remove(bought_item)
if success:
config.get('installed').append(bought_item)
else:
# Try again next time
config.get('bought').append(bought_item)
config.save()
# Only install one server at a time
return
else:
logger.log("Server not ready")
def install_available_servers(config, dna):
"""
This function checks if any of the bought servers are ready to be installed and installs
PlebNet on them.
:param config: The configuration of this Plebbot
:type config: dict
:param dna: The DNA of this Plebbot
:type dna: DNA
:return: None
:rtype: None
"""
bought = config.get('bought')
logger.log("install: %s" % bought, "install_available_servers")
for provider, transaction_hash, child_index in list(bought):
# skip vpn providers as they show up as 'bought' as well
if provider in cloudomate_controller.get_vpn_providers():
return
try:
provider_class = cloudomate_controller.get_vps_providers(
)[provider]
ip = cloudomate_controller.get_ip(
provider_class,
cloudomate_controller.child_account(child_index))
except Exception as e:
logger.log(
str(e) + "%s not ready yet" % str(provider),
"install_available_servers")
return
if is_valid_ip(ip):
# VPN configuration, enable tun/tap settings
if provider_class.TUN_TAP_SETTINGS:
tun_success = provider_class(
cloudomate_controller.child_account(
child_index)).enable_tun_tap()
logger.log("Enabling %s tun/tap: %s" % (provider, tun_success))
if not cloudomate_controller.save_info_vpn(child_index):
logger.log("VPN not ready yet, can't save ovpn config")
return
logger.log("Installing child on %s with ip %s" %
(provider, str(ip)))
account_settings = cloudomate_controller.child_account(child_index)
rootpw = account_settings.get('server', 'root_password')
provider_class(cloudomate_controller.child_account(
child_index)).change_root_password(rootpw)
time.sleep(5)
child_tree = dna.get_own_tree() + '.' + str(child_index)
dna.create_child_dna(provider, child_tree, transaction_hash)
# Save config before entering possibly long lasting process
config.save()
success = _install_server(ip, rootpw, child_index,
setup.get_instance().wallets_testnet())
# Reload config in case install takes a long time
config.load()
config.get('installed').append({provider: success})
if [provider, transaction_hash,
child_index] in config.get('bought'):
config.get('bought').remove(
[provider, transaction_hash, child_index])
config.save()
else:
logger.log("Server not ready")
def test_vps_providers(self):
r = cloudomate.get_vps_providers()
assert len(r) > 0
def test_attempt_purchase(self, mock1, mock2):
self.log = logger.log
self.testnet = plebnet_settings.Init.wallets_testnet
self.get = PlebNetConfig.get
self.get_balance = market_controller.get_balance
self.calculate_price = cloudomate_controller.calculate_price
self.purchase_choice = cloudomate_controller.purchase_choice
self.set = PlebNetConfig.set
self.save = PlebNetConfig.save
self.vpn = Core.attempt_purchase_vpn
self.new = PlebNetConfig.increment_child_index
self.provider = cloudomate_controller.get_vps_providers
self.fg = fake_generator.generate_child_account
self.qtable = QTable()
self.providers = cloudomate_controller.get_vps_providers()
providers = cloudomate_controller.get_vps_providers()
self.qtable.init_qtable_and_environment(providers)
self.qtable.set_self_state(VPSState("blueangelhost", "Basic Plan"))
logger.log = MagicMock()
plebnet_settings.Init.wallets_testnet = MagicMock(return_value=False)
PlebNetConfig.get = MagicMock(
return_value=['blueangelhost', 'Basic Plan', 0])
market_controller.get_balance = MagicMock(return_value=100000000)
Core.qtable = self.qtable
Core.attempt_purchase_vpn = MagicMock(return_value=False)
cloudomate_controller.calculate_price = MagicMock(return_value=0.01)
cloudomate_controller.purchase_choice = MagicMock(
return_value=plebnet_settings.SUCCESS)
PlebNetConfig.set = MagicMock()
PlebNetConfig.save = MagicMock()
PlebNetConfig.increment_child_index = MagicMock()
cloudomate_controller.get_vps_providers = MagicMock()
fake_generator.generate_child_account = MagicMock()
Core.config = PlebNetConfig
qtable_copy = copy.deepcopy(Core.qtable.qtable)
Core.attempt_purchase()
self.assertLess(
qtable_copy['blueangelhost_basic plan']
['blueangelhost_basic plan'],
Core.qtable.qtable['blueangelhost_basic plan']
['blueangelhost_basic plan'])
qtable_copy = copy.deepcopy(Core.qtable.qtable)
cloudomate_controller.purchase_choice = MagicMock(
return_value=plebnet_settings.FAILURE)
Core.attempt_purchase()
self.assertGreater(
qtable_copy['blueangelhost_basic plan']
['blueangelhost_basic plan'],
Core.qtable.qtable['blueangelhost_basic plan']
['blueangelhost_basic plan'])
logger.log = self.log
plebnet_settings.Init.wallets_testnet = self.testnet
PlebNetConfig.get = self.get
market_controller.get_balance = self.get_balance
cloudomate_controller.calculate_price = self.calculate_price
cloudomate_controller.purchase_choice = self.purchase_choice
Core.attempt_purchase_vpn = self.vpn
PlebNetConfig.set = self.set
PlebNetConfig.save = self.save
PlebNetConfig.increment_child_index = self.new
cloudomate_controller.get_vps_providers = self.provider
fake_generator.generate_child_account = self.fg
def setUp(self, mock1, mock2):
self.qtable = QTable()
self.providers = cloudomate_controller.get_vps_providers()