def add_order(self, orders): """ Inserts the given order into the database. @type orders: Order|list[Order] @param orders: The orders to be added. """ if orders is None: raise AttributeError('order argument must not be None') with self.engine.contextual_connect(close_with_result=True).begin(): for order in to_list(orders): self.__add_order(order)
def add_order(self, orders): """ Inserts the given order into the database. @type orders: Order|list[Order] @param orders: The orders to be added. """ if orders is None: raise AttributeError('order argument must not be None') with self.engine.contextual_connect(close_with_result = True).begin(): for order in to_list(orders): self.__add_order(order)
def __get_tasks_cond(self, **kwargs): tbl_t = self._table_map["task"] # Search conditions. where = None for field in ("id", "order_id", "job_id", "name", "status", "opened", "closed"): if field in kwargs: cond = None for value in to_list(kwargs.get(field)): cond = sa.or_(cond, tbl_t.c[field] == value) where = sa.and_(where, cond) return where
def __get_conditions(self, **kwargs): tbl_h = self._table_map['host'] where = None for field in ('address', 'name', 'protocol', 'tcp_port', 'path', 'country', 'city', 'os', 'duration', 'deleted'): if kwargs.has_key(field): cond = None for value in to_list(kwargs.get(field)): cond = sa.or_(cond, tbl_h.c[field] == value) where = sa.and_(where, cond) return where
def __get_orders_cond(self, **kwargs): tbl_o = self._table_map["order"] # Search conditions. where = None for field in ("id", "service", "description", "status", "created_by"): values = kwargs.get(field) if values is not None: cond = None for value in to_list(values): cond = sa.or_(cond, tbl_o.c[field].like(value)) where = sa.and_(where, cond) return where
def add_account(self, accounts): """ Adds one or more account instances to the pool. :type accounts: Account|list[Account] :param accounts: The account to be added. """ with self.unlock_cond: for account in to_list(accounts): account.acquired_event.listen(self._on_account_acquired) account.released_event.listen(self._on_account_released) self.accounts.add(account) self.unlocked_accounts.append(account) self.unlock_cond.notify_all()
def add_host(self, hosts): """ Inserts the given hosts into the database. @type orders: Host|list[Host] @param orders: The hosts to be added. @rtype: Boolean @return: True on success, False otherwise. """ if hosts is None: raise AttributeError('hosts argument must not be None') for host in to_list(hosts): self.__add_host(host) return True
def save_order(self, orders): """ Updates the given orders in the database. Does nothing if the order doesn't exist. @type orders: Order|list[Order] @param orders: The order to be saved. """ if orders is None: raise AttributeError('order argument must not be None') with self.engine.contextual_connect(close_with_result = True).begin(): for order in to_list(orders): self.__save_order(order)
def add_account(self, accounts): """ Adds one or more account instances to the pool. @type accounts: Account|list[Account] @param accounts: The account to be added. """ with self.unlock_cond: for account in to_list(accounts): account.acquired_event.listen(self._on_account_acquired) account.released_event.listen(self._on_account_released) self.accounts.add(account) self.unlocked_accounts.append(account) self.unlock_cond.notify_all()
def __get_orders_cond(self, **kwargs): tbl_o = self._table_map['order'] # Search conditions. where = None for field in ('id', 'service', 'description', 'status', 'created_by'): values = kwargs.get(field) if values is not None: cond = None for value in to_list(values): cond = sa.or_(cond, tbl_o.c[field].like(value)) where = sa.and_(where, cond) return where
def save_order(self, orders): """ Updates the given orders in the database. Does nothing if the order doesn't exist. @type orders: Order|list[Order] @param orders: The order to be saved. """ if orders is None: raise AttributeError('order argument must not be None') with self.engine.contextual_connect(close_with_result=True).begin(): for order in to_list(orders): self.__save_order(order)
def __get_tasks_cond(self, **kwargs): tbl_t = self._table_map['task'] # Search conditions. where = None for field in ('id', 'order_id', 'job_id', 'name', 'status', 'opened', 'closed'): if field in kwargs: cond = None for value in to_list(kwargs.get(field)): cond = sa.or_(cond, tbl_t.c[field] == value) where = sa.and_(where, cond) return where
def _remove_account(self, accounts): """ :type accounts: Account|list[Account] :param accounts: The accounts to be removed. """ for account in to_list(accounts): if account not in self.accounts: msg = 'attempt to remove unknown account %s' % account raise Exception(msg) if account not in self.unlocked_accounts: raise Exception('account %s should be unlocked' % account) account.acquired_event.disconnect(self._on_account_acquired) account.released_event.disconnect(self._on_account_released) self.accounts.remove(account) self.unlocked_accounts.remove(account)
def _remove_account(self, accounts): """ @type accounts: Account|list[Account] @param accounts: The accounts to be removed. """ for account in to_list(accounts): if account not in self.accounts: msg = "attempt to remove unknown account %s" % account raise Exception(msg) if account not in self.unlocked_accounts: raise Exception("account %s should be unlocked" % account) account.acquired_event.disconnect(self._on_account_acquired) account.released_event.disconnect(self._on_account_released) self.accounts.remove(account) self.unlocked_accounts.remove(account)
def save_host(self, hosts, fields=None): """ Updates the given hosts in the database. Does nothing if the host doesn't exist. If fields is a tuple of column names, only the fields with the given names are updated. @type hosts: Host|list[Host] @param hosts: The host to be saved. @rtype: Boolean @return: True on success, False otherwise. """ if hosts is None: raise AttributeError('hosts argument must not be None') for host in to_list(hosts): self.__save_host(host, fields, None) return True
def save_host(self, hosts, fields = None): """ Updates the given hosts in the database. Does nothing if the host doesn't exist. If fields is a tuple of column names, only the fields with the given names are updated. @type hosts: Host|list[Host] @param hosts: The host to be saved. @rtype: Boolean @return: True on success, False otherwise. """ if hosts is None: raise AttributeError('hosts argument must not be None') for host in to_list(hosts): self.__save_host(host, fields, None) return True
def get_orders(self, offset = 0, limit = None, **kwargs): """ Returns all orders that match the given criteria. @type offset: int @param offset: The offset of the first item to be returned. @type limit: int @param limit: The maximum number of items that is returned. @type kwargs: dict @param kwargs: The following keys may be used: - id - the id of the order (str) - service - the service name (str) - status - the status (str) All values may also be lists (logical OR). @rtype: list[Order] @return: The list of orders. """ tbl_o = self._table_map['order'] tbl_t = self._table_map['task'] # Search conditions. where = None for field in ('id', 'service', 'status'): if field in kwargs: cond = None for value in to_list(kwargs.get(field)): cond = sa.or_(cond, tbl_o.c[field] == value) where = sa.and_(where, cond) table = tbl_o.outerjoin(tbl_t, tbl_t.c.order_id == tbl_o.c.id) fields = list(tbl_o.c) fields.append(sa.func.avg(tbl_t.c.progress).label('avg_progress')) select = sa.select(fields, where, from_obj = [table], group_by = [tbl_o.c.id], order_by = [sa.desc(tbl_o.c.id)], offset = offset, limit = limit) return self.__get_orders_from_query(select)
def get_uri(self): """ Returns a URI formatted representation of the host, including all of it's attributes except for the name. Uses the address, not the name of the host to build the URI. @rtype: str @return: A URI. """ url = Url() url.protocol = self.get_protocol() url.hostname = self.get_address() url.port = self.get_tcp_port() url.vars = dict((k, to_list(v)) for (k, v) in self.get_all().iteritems() if isinstance(v, str) or isinstance(v, list)) if self.account: url.username = self.account.get_name() url.password1 = self.account.get_password() url.password2 = self.account.authorization_password return str(url)
def prompt(key, message, default = None, strip = True, check = None, history = None): """ Prompt the user for input. This function is similar to Python's built in raw_input, with the following differences: - You may specify a default value that is returned if the user presses "enter" without entering anything. - The user's input is recorded in a config file, and offered as the default value the next time this function is used (based on the key argument). The config file is based around the L{InputHistory}. If a history object is not passed in the history argument, a new one will be created. The key argument specifies under which name the input is saved in the config file. The given default value is only used if a default was not found in the history. The strip argument specifies that the returned value should be stripped of whitespace (default). The check argument allows for validating the input; if the validation fails, the user is prompted again before the value is stored in the InputHistory. Example usage:: def validate(input): if len(input) < 4: return 'Please enter at least 4 characters!' value = prompt('test', 'Enter a value', 'My Default', check = validate) print 'You entered:', value This leads to the following output:: Please enter a value [My Default]: abc Please enter at least 4 characters! Please enter a value [My Default]: Foobar You entered: Foobar The next time the same code is started, the input 'Foobar' is remembered:: Please enter a value [Foobar]: (enters nothing) You entered: Foobar @type key: str @param key: The key under which to store the input in the L{InputHistory}. @type message: str @param message: The user prompt. @type default: str|None @param default: The offered default if none was found in the history. @type strip: bool @param strip: Whether to remove whitespace from the input. @type check: callable @param check: A function that is called for validating the input. @type history: L{InputHistory}|None @param history: The history used for recording default values, or None. """ if history is None: history = InputHistory() default = history.get(key, str(default)) while True: if default is None: value = raw_input('%s: ' % message) else: value = raw_input('%s [%s]: ' % (message, default)) or default if strip: value = value.strip() if not check: break errors = check(value) if errors: print '\n'.join(to_list(errors)) else: break history.set(key, value) return value
def prompt(key, message, default=None, strip=True, check=None, history=None): """ Prompt the user for input. This function is similar to Python's built in raw_input, with the following differences: - You may specify a default value that is returned if the user presses "enter" without entering anything. - The user's input is recorded in a config file, and offered as the default value the next time this function is used (based on the key argument). The config file is based around the L{InputHistory}. If a history object is not passed in the history argument, a new one will be created. The key argument specifies under which name the input is saved in the config file. The given default value is only used if a default was not found in the history. The strip argument specifies that the returned value should be stripped of whitespace (default). The check argument allows for validating the input; if the validation fails, the user is prompted again before the value is stored in the InputHistory. Example usage:: def validate(input): if len(input) < 4: return 'Please enter at least 4 characters!' value = prompt('test', 'Enter a value', 'My Default', check = validate) print 'You entered:', value This leads to the following output:: Please enter a value [My Default]: abc Please enter at least 4 characters! Please enter a value [My Default]: Foobar You entered: Foobar The next time the same code is started, the input 'Foobar' is remembered:: Please enter a value [Foobar]: (enters nothing) You entered: Foobar @type key: str @param key: The key under which to store the input in the L{InputHistory}. @type message: str @param message: The user prompt. @type default: str|None @param default: The offered default if none was found in the history. @type strip: bool @param strip: Whether to remove whitespace from the input. @type check: callable @param check: A function that is called for validating the input. @type history: L{InputHistory}|None @param history: The history used for recording default values, or None. """ if history is None: history = InputHistory() default = history.get(key, str(default)) while True: if default is None: value = raw_input('%s: ' % message) else: value = raw_input('%s [%s]: ' % (message, default)) or default if strip: value = value.strip() if not check: break errors = check(value) if errors: print '\n'.join(to_list(errors)) else: break history.set(key, value) return value
def testToList(self): from Exscript.util.cast import to_list self.assertEqual(to_list(None), [None]) self.assertEqual(to_list([]), []) self.assertEqual(to_list('test'), ['test']) self.assertEqual(to_list(['test']), ['test'])