Rename Mgmt API to Admin API: methods names

QubesOS/qubes-issues#853

qubesadmin/app.py

@@ -56,7 +56,7 @@ def refresh_cache(self, force=False):
             return
         vm_list_data = self.app.qubesd_call(
             'dom0',
-            'mgmt.vm.List'
+            'admin.vm.List'
         )
         new_vm_list = {}
         # FIXME: this will probably change
@@ -95,7 +95,7 @@ def __contains__(self, item):
         return item in self._vm_list
 
     def __delitem__(self, key):
-        self.app.qubesd_call(key, 'mgmt.vm.Remove')
+        self.app.qubesd_call(key, 'admin.vm.Remove')
         self.clear_cache()
 
     def __iter__(self):
@@ -124,12 +124,12 @@ class QubesBase(qubesadmin.base.PropertyHolder):
     log = None
 
     def __init__(self):
-        super(QubesBase, self).__init__(self, 'mgmt.property.', 'dom0')
+        super(QubesBase, self).__init__(self, 'admin.property.', 'dom0')
         self.domains = VMCollection(self)
         self.labels = qubesadmin.base.WrapperObjectsCollection(
-            self, 'mgmt.label.List', qubesadmin.label.Label)
+            self, 'admin.label.List', qubesadmin.label.Label)
         self.pools = qubesadmin.base.WrapperObjectsCollection(
-            self, 'mgmt.pool.List', qubesadmin.storage.Pool)
+            self, 'admin.pool.List', qubesadmin.storage.Pool)
         #: cache for available storage pool drivers and options to create them
         self._pool_drivers = None
         self.log = logging.getLogger('app')
@@ -142,7 +142,7 @@ def _refresh_pool_drivers(self):
         '''
         if self._pool_drivers is None:
             pool_drivers_data = self.qubesd_call(
-                'dom0', 'mgmt.pool.ListDrivers', None, None)
+                'dom0', 'admin.pool.ListDrivers', None, None)
             assert pool_drivers_data.endswith(b'\n')
             pool_drivers = {}
             for driver_line in pool_drivers_data.decode('ascii').splitlines():
@@ -176,12 +176,12 @@ def add_pool(self, name, driver, **kwargs):
         payload = 'name={}\n'.format(name) + \
                   ''.join('{}={}\n'.format(key, value)
             for key, value in sorted(kwargs.items()))
-        self.qubesd_call('dom0', 'mgmt.pool.Add', driver,
+        self.qubesd_call('dom0', 'admin.pool.Add', driver,
             payload.encode('utf-8'))
 
     def remove_pool(self, name):
         ''' Remove a storage pool '''
-        self.qubesd_call('dom0', 'mgmt.pool.Remove', name, None)
+        self.qubesd_call('dom0', 'admin.pool.Remove', name, None)
 
     def get_label(self, label):
         '''Get label as identified by index or name
@@ -253,15 +253,15 @@ def add_new_vm(self, cls, name, label, template=None, pool=None,
         if pool and pools:
             raise ValueError('only one of pool= and pools= can be used')
 
-        method_prefix = 'mgmt.vm.Create.'
+        method_prefix = 'admin.vm.Create.'
         payload = 'name={} label={}'.format(name, label)
         if pool:
             payload += ' pool={}'.format(str(pool))
-            method_prefix = 'mgmt.vm.CreateInPool.'
+            method_prefix = 'admin.vm.CreateInPool.'
         if pools:
             payload += ''.join(' pool:{}={}'.format(vol, str(pool))
                 for vol, pool in sorted(pools.items()))
-            method_prefix = 'mgmt.vm.CreateInPool.'
+            method_prefix = 'admin.vm.CreateInPool.'
 
         self.qubesd_call('dom0', method_prefix + cls, template,
             payload.encode('utf-8'))
@@ -295,15 +295,15 @@ def clone_vm(self, src_vm, new_name, pool=None, pools=None):
         if not isinstance(src_vm, str):
             src_vm = str(src_vm)
 
-        method = 'mgmt.vm.Clone'
+        method = 'admin.vm.Clone'
         payload = 'name={}'.format(new_name)
         if pool:
             payload += ' pool={}'.format(str(pool))
-            method = 'mgmt.vm.CloneInPool'
+            method = 'admin.vm.CloneInPool'
         if pools:
             payload += ''.join(' pool:{}={}'.format(vol, str(pool))
                 for vol, pool in sorted(pools.items()))
-            method = 'mgmt.vm.CloneInPool'
+            method = 'admin.vm.CloneInPool'
 
         self.qubesd_call(src_vm, method, None, payload.encode('utf-8'))
 
@@ -374,7 +374,7 @@ def run_service(self, dest, service, filter_esc=False, user=None,
         if not dest:
             raise ValueError('Empty destination name allowed only from a VM')
         try:
-            self.qubesd_call(dest, 'mgmt.vm.Start')
+            self.qubesd_call(dest, 'admin.vm.Start')
         except qubesadmin.exc.QubesVMNotHaltedError:
             pass
         qrexec_opts = ['-d', dest]

qubesadmin/base.py

@@ -52,7 +52,7 @@ def qubesd_call(self, dest, method, arg=None, payload=None):
         defined by a subclass.
 
         :param dest: Destination VM name
-        :param method: Full API method name ('mgmt...')
+        :param method: Full API method name ('admin...')
         :param arg: Method argument (if any)
         :param payload: Payload send to the method
         :return: Data returned by qubesd (string)

qubesadmin/devices.py

@@ -127,7 +127,7 @@ def attach(self, device_assignment):
         options_str = ' '.join('{}={}'.format(opt,
             val) for opt, val in sorted(options.items()))
         self._vm.qubesd_call(None,
-            'mgmt.vm.device.{}.Attach'.format(self._class),
+            'admin.vm.device.{}.Attach'.format(self._class),
             '{!s}+{!s}'.format(device_assignment.backend_domain,
                 device_assignment.ident),
             options_str.encode('utf-8'))
@@ -145,7 +145,7 @@ def detach(self, device_assignment):
                 "Trying to detach DeviceAssignment belonging to other domain"
 
         self._vm.qubesd_call(None,
-            'mgmt.vm.device.{}.Detach'.format(self._class),
+            'admin.vm.device.{}.Detach'.format(self._class),
             '{!s}+{!s}'.format(device_assignment.backend_domain,
                 device_assignment.ident))
 
@@ -162,7 +162,7 @@ def assignments(self, persistent=None):
         '''
 
         assignments_str = self._vm.qubesd_call(None,
-            'mgmt.vm.device.{}.List'.format(self._class)).decode()
+            'admin.vm.device.{}.List'.format(self._class)).decode()
         for assignment_str in assignments_str.splitlines():
             device, _, options_all = assignment_str.partition(' ')
             backend_domain, ident = device.split('+', 1)
@@ -199,7 +199,7 @@ def _device(self, assignment):
     def available(self):
         '''List devices exposed by this vm'''
         devices_str = self._vm.qubesd_call(None,
-            'mgmt.vm.device.{}.Available'.format(self._class)).decode()
+            'admin.vm.device.{}.Available'.format(self._class)).decode()
         for dev_str in devices_str.splitlines():
             ident, _, info = dev_str.partition(' ')
             # description is special that it can contain spaces

qubesadmin/events/__init__.py

@@ -77,7 +77,7 @@ def _get_events_reader(self, vm=None) -> (asyncio.StreamReader, callable):
             reader, writer = yield from asyncio.open_unix_connection(
                 qubesadmin.config.QUBESD_SOCKET)
             writer.write(b'dom0\0')  # source
-            writer.write(b'mgmt.Events\0')  # method
+            writer.write(b'admin.Events\0')  # method
             writer.write(dest.encode('ascii') + b'\0')  # dest
             writer.write(b'\0')  # arg
             writer.write_eof()
@@ -87,7 +87,7 @@ def cleanup_func():
                 writer.close()
         elif self.app.qubesd_connection_type == 'qrexec':
             proc = yield from asyncio.create_subprocess_exec(
-                ['qrexec-client-vm', dest, 'mgmt.Events'],
+                ['qrexec-client-vm', dest, 'admin.Events'],
                 stdin=subprocess.PIPE, stdout=subprocess.PIPE)
 
             proc.stdin.write_eof()

qubesadmin/features.py

@@ -39,18 +39,18 @@ def __init__(self, vm):
         self.vm = vm
 
     def __delitem__(self, key):
-        self.vm.qubesd_call(self.vm.name, 'mgmt.vm.feature.Remove', key)
+        self.vm.qubesd_call(self.vm.name, 'admin.vm.feature.Remove', key)
 
     def __setitem__(self, key, value):
-        self.vm.qubesd_call(self.vm.name, 'mgmt.vm.feature.Set', key, value)
+        self.vm.qubesd_call(self.vm.name, 'admin.vm.feature.Set', key, value)
 
     def __getitem__(self, item):
         return self.vm.qubesd_call(
-            self.vm.name, 'mgmt.vm.feature.Get', item).decode('utf-8')
+            self.vm.name, 'admin.vm.feature.Get', item).decode('utf-8')
 
     def __iter__(self):
         qubesd_response = self.vm.qubesd_call(self.vm.name,
-            'mgmt.vm.feature.List')
+            'admin.vm.feature.List')
         return iter(qubesd_response.decode('utf-8').splitlines())
 
     keys = __iter__
@@ -61,7 +61,7 @@ def check_with_template(self, feature, default=_NO_DEFAULT):
         ''' Check if the vm's template has the specified feature. '''
         try:
             qubesd_response = self.vm.qubesd_call(
-                self.vm.name, 'mgmt.vm.feature.CheckWithTemplate', feature)
+                self.vm.name, 'admin.vm.feature.CheckWithTemplate', feature)
             return qubesd_response.decode('utf-8')
         except KeyError:
             if default is self._NO_DEFAULT:

qubesadmin/firewall.py

@@ -394,7 +394,7 @@ def __init__(self, vm):
 
     def load_rules(self):
         '''Force (re-)loading firewall rules'''
-        rules_str = self.vm.qubesd_call(None, 'mgmt.vm.firewall.Get')
+        rules_str = self.vm.qubesd_call(None, 'admin.vm.firewall.Get')
         rules = []
         for rule_str in rules_str.decode().splitlines():
             rules.append(Rule(rule_str))
@@ -425,24 +425,24 @@ def save_rules(self, rules=None):
         '''
         if rules is None:
             rules = self._rules
-        self.vm.qubesd_call(None, 'mgmt.vm.firewall.Set',
+        self.vm.qubesd_call(None, 'admin.vm.firewall.Set',
             payload=(''.join('{}\n'.format(rule.rule)
                 for rule in rules)).encode('ascii'))
 
     @property
     def policy(self):
         '''Default action to take if no rule matches'''
-        policy_str = self.vm.qubesd_call(None, 'mgmt.vm.firewall.GetPolicy')
+        policy_str = self.vm.qubesd_call(None, 'admin.vm.firewall.GetPolicy')
         return Action(policy_str.decode())
 
     @policy.setter
     def policy(self, value):
-        self.vm.qubesd_call(None, 'mgmt.vm.firewall.SetPolicy', payload=str(
+        self.vm.qubesd_call(None, 'admin.vm.firewall.SetPolicy', payload=str(
             value).encode('ascii'))
 
     def reload(self):
         '''Force reload the same firewall rules.
 
         Can be used for example to force again names resolution.
         '''
-        self.vm.qubesd_call(None, 'mgmt.vm.firewall.Reload')
+        self.vm.qubesd_call(None, 'admin.vm.firewall.Reload')

qubesadmin/label.py

@@ -44,7 +44,7 @@ def color(self):
         if self._color is None:
             try:
                 qubesd_response = self.app.qubesd_call(
-                    'dom0', 'mgmt.label.Get', self._name, None)
+                    'dom0', 'admin.label.Get', self._name, None)
             except qubesadmin.exc.QubesDaemonNoResponseError:
                 raise AttributeError
             self._color = qubesd_response.decode()
@@ -67,7 +67,7 @@ def index(self):
         if self._index is None:
             try:
                 qubesd_response = self.app.qubesd_call(
-                    'dom0', 'mgmt.label.Index', self._name, None)
+                    'dom0', 'admin.label.Index', self._name, None)
             except qubesadmin.exc.QubesDaemonNoResponseError:
                 raise AttributeError
             self._index = int(qubesd_response.decode())

qubesadmin/storage.py

@@ -54,11 +54,11 @@ def _qubesd_call(self, func_name, payload=None):
         :param bytes payload: Payload to send.
         '''
         if self._vm is not None:
-            method = 'mgmt.vm.volume.' + func_name
+            method = 'admin.vm.volume.' + func_name
             dest = self._vm
             arg = self._vm_name
         else:
-            method = 'mgmt.pool.volume.' + func_name
+            method = 'admin.pool.volume.' + func_name
             dest = 'dom0'
             arg = self._pool
             if payload is not None:
@@ -213,7 +213,7 @@ def config(self):
         ''' Storage pool config '''
         if self._config is None:
             pool_info_data = self.app.qubesd_call(
-                'dom0', 'mgmt.pool.Info', self.name, None)
+                'dom0', 'admin.pool.Info', self.name, None)
             pool_info_data = pool_info_data.decode('utf-8')
             assert pool_info_data.endswith('\n')
             pool_info_data = pool_info_data[:-1]
@@ -230,7 +230,7 @@ def driver(self):
     def volumes(self):
         ''' Volumes managed by this pool '''
         volumes_data = self.app.qubesd_call(
-            'dom0', 'mgmt.pool.volume.List', self.name, None)
+            'dom0', 'admin.pool.volume.List', self.name, None)
         assert volumes_data.endswith(b'\n')
         volumes_data = volumes_data[:-1].decode('ascii')
         for vid in volumes_data.splitlines():