def init_client_storage_broker(self): # create a StorageFarmBroker object, for use by Uploader/Downloader # (and everybody else who wants to use storage servers) sb = storage_client.StorageFarmBroker(self.tub, permute_peers=True) self.storage_broker = sb # load static server specifications from tahoe.cfg, if any. # Not quite ready yet. #if self.config.has_section("client-server-selection"): # server_params = {} # maps serverid to dict of parameters # for (name, value) in self.config.items("client-server-selection"): # pieces = name.split(".") # if pieces[0] == "server": # serverid = pieces[1] # if serverid not in server_params: # server_params[serverid] = {} # server_params[serverid][pieces[2]] = value # for serverid, params in server_params.items(): # server_type = params.pop("type") # if server_type == "tahoe-foolscap": # s = storage_client.NativeStorageClient(*params) # else: # msg = ("unrecognized server type '%s' in " # "tahoe.cfg [client-server-selection]server.%s.type" # % (server_type, serverid)) # raise storage_client.UnknownServerTypeError(msg) # sb.add_server(s.serverid, s) # check to see if we're supposed to use the introducer too if self.get_config("client-server-selection", "use_introducer", default=True, boolean=True): sb.use_introducer(self.introducer_client)
def init_client_storage_broker(self): # create a StorageFarmBroker object, for use by Uploader/Downloader # (and everybody else who wants to use storage servers) ps = self.get_config("client", "peers.preferred", "").split(",") preferred_peers = tuple([p.strip() for p in ps if p != ""]) sb = storage_client.StorageFarmBroker( permute_peers=True, tub_maker=self._create_tub, preferred_peers=preferred_peers, ) self.storage_broker = sb sb.setServiceParent(self) for ic in self.introducer_clients: sb.use_introducer(ic)
def init_client_storage_broker(self): # create a StorageFarmBroker object, for use by Uploader/Downloader # (and everybody else who wants to use storage servers) ps = self.get_config("client", "peers.preferred", "").split(",") preferred_peers = tuple([p.strip() for p in ps if p != ""]) sb = storage_client.StorageFarmBroker(permute_peers=True, preferred_peers=preferred_peers, tub_options=self.tub_options, tub_handlers=self.tub_handlers) self.storage_broker = sb sb.setServiceParent(self) # utilize the loaded static server specifications for key, server in self.connections_config['servers'].items(): handlers = server.get("transport_handlers") eventually(self.storage_broker.got_static_announcement, key, server['announcement'], handlers) sb.use_introducer(self.introducer_client)
def init_client_storage_broker(self): # create a StorageFarmBroker object, for use by Uploader/Downloader # (and everybody else who wants to use storage servers) ps = self.get_config("client", "peers.preferred", "").split(",") preferred_peers = tuple([p.strip() for p in ps if p != ""]) sb = storage_client.StorageFarmBroker(permute_peers=True, preferred_peers=preferred_peers, tub_options=self.tub_options) self.storage_broker = sb sb.setServiceParent(self) connection_threshold = min(self.encoding_params["k"], self.encoding_params["happy"] + 1) helper = storage_client.ConnectedEnough(sb, connection_threshold) self.upload_ready_d = helper.when_connected_enough() # load static server specifications from tahoe.cfg, if any. # Not quite ready yet. #if self.config.has_section("client-server-selection"): # server_params = {} # maps serverid to dict of parameters # for (name, value) in self.config.items("client-server-selection"): # pieces = name.split(".") # if pieces[0] == "server": # serverid = pieces[1] # if serverid not in server_params: # server_params[serverid] = {} # server_params[serverid][pieces[2]] = value # for serverid, params in server_params.items(): # server_type = params.pop("type") # if server_type == "tahoe-foolscap": # s = storage_client.NativeStorageClient(*params) # else: # msg = ("unrecognized server type '%s' in " # "tahoe.cfg [client-server-selection]server.%s.type" # % (server_type, serverid)) # raise storage_client.UnknownServerTypeError(msg) # sb.add_server(s.serverid, s) # check to see if we're supposed to use the introducer too if self.get_config("client-server-selection", "use_introducer", default=True, boolean=True): sb.use_introducer(self.introducer_client)
def create_storage_farm_broker(config, default_connection_handlers, foolscap_connection_handlers, tub_options, introducer_clients): """ Create a StorageFarmBroker object, for use by Uploader/Downloader (and everybody else who wants to use storage servers) :param config: a _Config instance :param default_connection_handlers: default Foolscap handlers :param foolscap_connection_handlers: available/configured Foolscap handlers :param dict tub_options: how to configure our Tub :param list introducer_clients: IntroducerClient instances if we're connecting to any """ storage_client_config = storage_client.StorageClientConfig.from_node_config( config, ) def tub_creator(handler_overrides=None, **kwargs): return node.create_tub( tub_options, default_connection_handlers, foolscap_connection_handlers, handler_overrides={} if handler_overrides is None else handler_overrides, **kwargs) sb = storage_client.StorageFarmBroker( permute_peers=True, tub_maker=tub_creator, node_config=config, storage_client_config=storage_client_config, ) for ic in introducer_clients: sb.use_introducer(ic) return sb