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')
