def read_file(self, domain): filename = self.directory + '/' + domain if not os.path.isfile(filename): raise dss_error.Error('Key not found %s' % domain) try: with open(filename) as f: return f.read().splitlines() except Exception as exp: raise dss_error.Error('Failed with error %s' % exp)
def get(self, domain, name): lines = self.read_file(domain) try: for line in lines: index = line.find('=') part0 = line[:index] part1 = line[index + 1:] if name == part0: return part1 except Exception as exp: raise dss_error.Error('Failed with error %s' % exp) raise dss_error.Error('Key not found %s/%s' % (domain, name))
def get_domains(self): ret = [] try: entries = os.listdir(self.directory) for entry in entries: filename = self.directory + '/' + entry if os.path.isfile(filename): ret.append(entry) if not ret: raise dss_error.Error('No domains found') return ret except Exception as exp: raise dss_error.Error('Failed with error %s' % exp)
def __init__(self, config_file): super(dssfile, self).__init__(config_file) self.directory = None try: config = ConfigParser.ConfigParser() config.read([config_file]) self.directory = config.get('default', 'directory') except Exception as exp: raise dss_error.Error( 'Failed to parse configuration, got error %s' % exp) if not os.path.isdir(self.directory): raise dss_error.Error('%s is not a valid directory name' % self.directory)
def __init__(self, config_file=DEFAULT_CONFIG_FILE): try: # server self.logging_level = None self.logging_destination = None self.verbose = None self.listening_uds = None self.transport_type = None # plugin self.plugin = None self.plugin_config = None config = ConfigParser.ConfigParser() config.read([config_file]) self.logging_level = config.get(SERVER_SECTION, "logging_level") self.logging_destination = config.get(SERVER_SECTION, "logging_destination") self.verbose = config.get(SERVER_SECTION, "verbose") self.listening_uds = config.get(SERVER_SECTION, "listening_uds") self.transport_type = config.get(SERVER_SECTION, "transport_type") self.plugin = config.get(PLUGIN_SECTION, "plugin") self.plugin_config = config.get(PLUGIN_SECTION, "config") except Exception as exp: raise dss_error.Error(str(exp))
def str_to_level(level): ret = None try: ret = Logger.levels[level] except KeyError as exp: raise dss_error.Error('Invalid log level, possible values %s' % str(Logger.levels.keys())) return ret
def str_to_dest(dest): ret = None try: ret = Logger.dests[dest] except KeyError as exp: raise dss_error.Error('Invalid destination, possible values %s' % str(Logger.dests.keys())) return ret
def _connect(self): try: self.client = etcd.Client(self.host, self.port) self.connected = True except Exception as exp: self.connected = False raise dss_error.Error(exp)
def write_file(self, domain, lines): filename = self.directory + '/' + domain try: with open(filename, 'w') as f: for line in lines: f.write(line + '\n') except Exception as exp: raise dss_error.Error('Failed with error %s' % exp)
def test_get_domains_exception(self, mock_logging, mock_dss_client): handler = CMDSSHandler(uri='test_uri') mock_dss_client.return_value.get_domains.side_effect = dss_error.Error( 'no domains') with self.assertRaises(CMError) as context: handler.get_domains()
def set(self, domain, name, value): if not self.connected: self._connect() try: self.client.write('/' + domain + '/' + name, value) except Exception as exp: raise dss_error.Error(exp)
def delete_domain(self, domain): if not self.connected: self._connect() try: self.client.delete('/' + domain, recursive=True, dir=True) except Exception as exp: raise dss_error.Error(exp)
def delete(self, domain, name): if not self.connected: self._connect() try: self.client.delete('/' + domain + '/' + name) except Exception as exp: raise dss_error.Error(exp)
def get(self, domain, name): if not self.connected: self._connect() try: value = self.client.read('/' + domain + '/' + name) return value.value except Exception as exp: raise dss_error.Error(exp)
def deserialize(self, msg): data = json.loads(msg, object_pairs_hook=OrderedDict) self.name = data['name'] self.id = data['id'] self.result = data['result'] self.payload = data['payload'] if self.result != 'OK': raise dss_error.Error('Request failed with error %s' % self.result)
def delete(self, domain, name): lines = self.read_file(domain) found_index = -1 try: for index, line in enumerate(lines): i = line.find('=') part0 = line[:i] part1 = line[i + 1:] if part0 == name: found_index = index break if found_index != -1: del lines[found_index] self.write_file(domain, lines) except Exception as exp: raise dss_error.Error('Failed with error %s' % exp) if found_index == -1: raise dss_error.Error('%s/%s not found' % (domain, name))
def __init__(self, config): try: plugin_file = config.get_plugin() location = os.path.dirname(plugin_file) pluginname = os.path.basename(plugin_file).replace(".py", "") sys.path.append(location) self.plugin = None self._load_plugin(pluginname, config.get_plugin_config()) except Exception as exp: raise dss_error.Error(str(exp))
def test_set_dss_fails(self, mock_logging, mock_dss_client): handler = CMDSSHandler(uri='test_uri') mock_dss_client.return_value.set.side_effect = dss_error.Error( 'some error') with self.assertRaises(CMError) as context: handler.set('a domain', 'a name', 'a value') mock_dss_client.return_value.set.assert_called_once_with( 'a domain', 'a name', 'a value')
def get_domains(self): """Get the domains list Arguments: Return: A list containing domain names Raise: dss_error.Error can raised in case of an error """ raise dss_error.Error('Not implemented')
def get_domain(self, domain): """Get all the attributes in a domain Arguments: Return: A dictionary. Raise: dss_error.Error can raised in case of an error """ raise dss_error.Error('Not implemented')
def get_domains(self): if not self.connected: self._connect() ret = [] try: domains = self.client.read('/') for domain in domains._children: if 'dir' in domain and domain['dir'] and 'key' in domain: d = domain['key'] v = d.split('/')[1] ret.append(v) return ret except Exception as exp: raise dss_error.Error(exp)
def init(self): args = {} if self.level not in Logger.levels.values(): raise dss_error.Error('Invalid level value, possible values are %s' % str(Logger.levels)) if self.dest not in Logger.dests.values(): raise dss_error.Error('Invalid destination value, possible values are %s' % str(Logger.dests)) if self.verbose: if self.dest is Logger.DEST_CONSOLE: args['format'] = '[%(asctime)s %(levelname)7s %(module)s(%(lineno)3s)] %(message)s' else: args['format'] = '[%(module)s(%(lineno)3s)] %(message)s' else: args['format'] = '%(message)s' if self.dest is Logger.DEST_CONSOLE: args['stream'] = sys.stdout elif self.dest is Logger.DEST_SYSLOG: logging.getLogger('').addHandler(logging.handlers.SysLogHandler(address='/dev/log')) args['level'] = self.level logging.basicConfig(**args)
def test_get_domain_dss_fails(self, mock_logging, mock_dss_client): handler = CMDSSHandler(uri='test_uri') mock_dss_client.return_value.get_domains.return_value = [ 'a domain', 'b domain', 'c domain' ] mock_dss_client.return_value.get_domain.side_effect = dss_error.Error( 'some error') with self.assertRaises(CMError) as context: domain = handler.get_domain('a domain') mock_dss_client.return_value.get_domains.assert_called_once() mock_dss_client.return_value.get_domain.assert_called_once_with( 'a domain')
def get_domain(self, domain): if not self.connected: self._connect() ret = {} try: values = self.client.read('/' + domain) for value in values._children: if 'dir' not in value and 'key' in value: k = value['key'] n = k.split('/')[2] v = value['value'] ret[n] = v return ret except Exception as exp: raise dss_error.Error(exp)
def set(self, domain, name, value): """set an attribute to some value Arguments: domain: The domain name. name: The attribute name. value: The value. Raise: dss_error.Error can be raised in-case of an error. """ raise dss_error.Error('Not implemented')
def _call_rpc(self, msg): self.id += 1 repmsg = dss_msg.Msg() try: self._connect() req = msg.serialize() self.sock.sendall(req+'\n') rep = self.fd.readline() except Exception as exp: try: self.sock.close() except: pass self.connect = True raise dss_error.Error(str(exp)) repmsg.deserialize(rep) return repmsg
def get(self, domain, name): """get the value associated with an attribute Arguments: domain: The domain name. name: The attribute name. Return: The value Raise: dss_error.Error can be raised in-case of an error. """ raise dss_error.Error('Not implemented')
def test_delete_dss_fails(self, mock_logging, mock_dss_client): handler = CMDSSHandler(uri='test_uri') mock_dss_client.return_value.get_domains.return_value = [ 'a domain', 'b domain', 'c domain' ] mock_dss_client.return_value.get_domain.return_value = OrderedDict([ ('name', 'value') ]) mock_dss_client.return_value.delete.side_effect = dss_error.Error( 'some error') with self.assertRaises(CMError) as context: handler.delete('a domain', 'name') mock_dss_client.return_value.delete.assert_called_once_with( 'a domain', 'name')
def set(self, domain, name, value): filename = self.directory + '/' + domain lines = [] if os.path.isfile(filename): lines = self.read_file(domain) try: found = False for index, line in enumerate(lines): i = line.find('=') part0 = line[:i] part1 = line[i + 1:] if part0 == name: found = True lines[index] = name + '=' + value break if not found: lines.append(name + '=' + value) self.write_file(domain, lines) except Exception as exp: raise dss_error.Error('Failed with error %s' % exp)
def shutdown(self): raise dss_error.Error('Not implemented')