nectar-osc 1.0.0__py3-none-any.whl

nectar_osc/compute.py

@@ -0,0 +1,121 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import json
+import six
+import sys
+
+from novaclient import exceptions as n_exc
+from prettytable import PrettyTable
+
+
+def _format_instance(d, style=None):
+    """Pretty print instance info for the command line"""
+    pt = PrettyTable(['Property', 'Value'], caching=False)
+    pt.align = 'l'
+    for k, v in sorted(d.items()):
+        # convert dict to str to check length
+        if isinstance(v, (dict, list)):
+            v = json.dumps(v)
+        # if value has a newline, add in multiple rows
+        # e.g. fault with stacktrace
+        if v and isinstance(v, six.string_types) and (r'\n' in v or '\r' in v):
+            # '\r' would break the table, so remove it.
+            if '\r' in v:
+                v = v.replace('\r', '')
+            lines = v.strip().split(r'\n')
+            col1 = k
+            for line in lines:
+                pt.add_row([col1, line])
+                col1 = ''
+        else:
+            if v is None:
+                v = '-'
+            pt.add_row([k, v])
+
+    if style == 'html':
+        output = '<b>Instance details</b>'
+        output += pt.get_html_string(
+            attributes={
+                'border': 1,
+                'style': 'border-width: 1px; border-collapse: collapse;',
+            }
+        )
+    else:
+        output = 'Instance details:\n'
+        output += pt.get_string()
+    return output
+
+
+def show_instance(clients, instance_id, style=None):
+    try:
+        instance = clients.compute.servers.get(instance_id)
+    except n_exc.NotFound:
+        print(f"Instance {instance_id} not found")
+        sys.exit(1)
+
+    info = instance._info.copy()
+    for network_label, address_list in instance.networks.items():
+        info[f'{network_label} network'] = ', '.join(address_list)
+
+    flavor = info.get('flavor', {})
+    flavor_id = flavor.get('id', '')
+
+    try:
+        info['flavor'] = (
+            f'{clients.compute.flavors.get(flavor_id).name} ({flavor_id})'
+        )
+    except Exception:
+        info['flavor'] = '{} ({})'.format("Flavor not found", flavor_id)
+
+    # Image
+    image = info.get('image', {})
+    if image:
+        image_id = image.get('id', '')
+        try:
+            img = clients.image.images.get(image_id)
+            nectar_build = img.get('nectar_build', 'N/A')
+            info['image'] = (
+                f'{img.name} ({img.id}, NeCTAR Build {nectar_build})'
+            )
+        except Exception:
+            info['image'] = f'Image not found ({image_id})'
+
+    else:  # Booted from volume
+        info['image'] = "Attempt to boot from volume - no image supplied"
+
+    # Tenant
+    project_id = info.get('tenant_id')
+    if project_id:
+        try:
+            project = clients.identity.projects.get(project_id)
+            info['tenant_id'] = f'{project.name} ({project.id})'
+        except Exception:
+            pass
+
+    # User
+    user_id = info.get('user_id')
+    if user_id:
+        try:
+            user = clients.identity.users.get(user_id)
+            info['user_id'] = f'{user.name} ({user.id})'
+        except Exception:
+            pass
+
+    # Remove stuff
+    info.pop('links', None)
+    info.pop('addresses', None)
+    info.pop('hostId', None)
+    info.pop('security_groups', None)
+
+    return _format_instance(info, style=style)

nectar_osc/config.py

@@ -0,0 +1,62 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import sys
+
+from oslo_config import cfg
+from oslo_config import generator
+from pathlib import Path
+
+
+homedir = str(Path.home())
+if not Path(homedir).exists():
+    print(f'config dir {homedir} doesnt exist')
+    sys.exit(1)
+
+
+freshdesk_opts = [
+    cfg.StrOpt('api_key', help='your freshdesk api key'),
+    cfg.IntOpt(
+        'email_config_id',
+        default='6000071619',
+        help='freshdesk email config id',
+    ),
+    cfg.IntOpt('group_id', default='6000208874', help='freshdesk group id'),
+    cfg.StrOpt(
+        'domain', default='dhdnectar.freshdesk.com', help='freshdesk domain'
+    ),
+]
+
+cfg.CONF.register_opts(freshdesk_opts, group='freshdesk')
+
+
+def list_opts():
+    return [
+        ('freshdesk', freshdesk_opts),
+    ]
+
+
+def init():
+    try:
+        cfg.CONF(
+            [],
+            project='nectar-osc',
+            default_config_files=['~/.nectar-osc.conf'],
+        )
+    except cfg.ConfigFilesNotFoundError:
+        print('generating config file ~/.nectar-osc.conf')
+        conf = cfg.ConfigOpts()
+        generator.register_cli_opts(conf)
+        conf.namespace = ['nectar_osc']
+        with open(homedir + '/' + '.nectar-osc.conf', 'w') as conf_file:
+            generator.generate(conf, conf_file)

nectar_osc/freshdesk.py

@@ -0,0 +1,59 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import sys
+
+try:
+    from freshdesk.v2 import api
+except ImportError:
+    api = None
+
+from nectar_osc import config
+from oslo_config import cfg
+
+
+CONF = cfg.CONF
+
+
+def get_client():
+    if not api:
+        print(
+            "To use this tool, you will need to also install the"
+            "python-freshdesk package: \n"
+            "  $ pip install python-freshdesk"
+        )
+        sys.exit(1)
+
+    msg = '\n'.join(
+        [
+            'No Freshdesk api key found in your config file.',
+            '',
+            'To find your Freshdesk API key by following the guide here:',
+            'https://support.freshdesk.com/support/solutions/'
+            'articles/215517-how-to-find-your-api-key',
+            '',
+            'Then add the following config to your configuration',
+            'file (~/.nectar-osc.conf):',
+            '',
+            '  [freshdesk]',
+            '  api_key = <your api key>',
+        ]
+    )
+
+    config.init()
+
+    if not CONF.freshdesk.api_key:
+        print(msg)
+        sys.exit(1)
+
+    return api.API(CONF.freshdesk.domain, CONF.freshdesk.api_key)

nectar_osc/identity.py

@@ -0,0 +1,26 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+
+def get_tenant_managers_emails(identity, instance):
+    """Build a list of email addresses"""
+    email_addresses = []
+    project = identity.projects.get(instance.tenant_id)
+    role = identity.roles.find(name='TenantManager')
+    ras = identity.role_assignments.list(
+        project=project, role=role, include_names=True
+    )
+    for ra in ras:
+        u = identity.users.get(ra.user['id'])
+        email_addresses.append(u.email)
+    return email_addresses

nectar_osc/network.py

@@ -0,0 +1,128 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+from prettytable import PrettyTable
+
+from neutronclient.v2_0 import client as nclient
+
+
+def _get_sg_remote(rule):
+    if rule['remote_ip_prefix']:
+        remote = '{} (CIDR)'.format(rule['remote_ip_prefix'])
+    elif rule['remote_group_id']:
+        remote = '{} (group)'.format(rule['remote_group_id'])
+    else:
+        remote = None
+    return remote
+
+
+def _get_sg_protocol_port(rule):
+    proto = rule['protocol']
+    port_min = rule['port_range_min']
+    port_max = rule['port_range_max']
+    if proto in ('tcp', 'udp'):
+        if port_min and port_min == port_max:
+            protocol_port = f'{port_min}/{proto}'
+        elif port_min:
+            protocol_port = f'{port_min}-{port_max}/{proto}'
+        else:
+            protocol_port = proto
+    elif proto == 'icmp':
+        icmp_opts = []
+        if port_min is not None:
+            icmp_opts.append(f'type:{port_min}')
+        if port_max is not None:
+            icmp_opts.append(f'code:{port_max}')
+
+        if icmp_opts:
+            protocol_port = 'icmp ({})'.format(', '.join(icmp_opts))
+        else:
+            protocol_port = 'icmp'
+    elif proto is not None:
+        # port_range_min/max are not recognized for protocol
+        # other than TCP, UDP and ICMP.
+        protocol_port = proto
+    else:
+        protocol_port = None
+    return protocol_port
+
+
+def _format_sg_rule(rule):
+    formatted = []
+    for field in [
+        'direction',
+        'ethertype',
+        ('protocol_port', _get_sg_protocol_port),
+        'remote_ip_prefix',
+        'remote_group_id',
+    ]:
+        if isinstance(field, tuple):
+            field, get_method = field
+            data = get_method(rule)
+        else:
+            data = rule[field]
+        if not data:
+            continue
+        if field in ('remote_ip_prefix', 'remote_group_id'):
+            data = f'{field}: {data}'
+        formatted.append(data)
+    return ', '.join(formatted)
+
+
+def _format_sg_rules(secgroup):
+    try:
+        return '\n'.join(
+            sorted(
+                [
+                    _format_sg_rule(rule)
+                    for rule in secgroup['security_group_rules']
+                ]
+            )
+        )
+    except Exception:
+        return ''
+
+
+def _format_secgroups(security_groups, style=None):
+    pt = PrettyTable(['ID', 'Name', 'Rules'], caching=False)
+    pt.align = 'l'
+
+    for sg in security_groups['security_groups']:
+        pt.add_row([sg['id'], sg['name'], _format_sg_rules(sg)])
+
+    if style == 'html':
+        output = '<b>Security Groups</b>'
+        output += pt.get_html_string(
+            attributes={
+                'border': 1,
+                'style': 'border-width: 1px; border-collapse: collapse;',
+            }
+        )
+    else:
+        output = 'Security Groups:\n'
+        output += pt.get_string()
+    return output
+
+
+def show_instance_security_groups(clients, instance_id, style=None):
+    nc = nclient.Client(session=clients.session)
+
+    ports = nc.list_ports(device_id=instance_id)
+    sg_ids = [
+        sg
+        for sgs in [p['security_groups'] for p in ports['ports']]
+        for sg in sgs
+    ]
+    security_groups = nc.list_security_groups(id=sg_ids)
+
+    return _format_secgroups(security_groups, style=style)

nectar_osc/plugin.py

@@ -0,0 +1,48 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+
+DEFAULT_API_VERSION = '1'
+
+# Required by the OSC plugin interface
+API_NAME = 'nectar'
+API_VERSION_OPTION = 'nectar'
+API_VERSIONS = {
+    '1': 'nectar_osc.v1.client.Client',
+}
+
+
+# Required by the OSC plugin interface
+def make_client(instance):
+    """Returns a client to the ClientManager
+
+    Called to instantiate the requested client version.  instance has
+    any available auth info that may be required to prepare the client.
+
+    :param ClientManager instance: The ClientManager that owns the new client
+    """
+    return None
+
+
+# Required by the OSC plugin interface
+def build_option_parser(parser):
+    """Hook to add global options
+
+    Called from openstackclient.shell.OpenStackShell.__init__()
+    after the builtin parser has been initialized.  This is
+    where a plugin can add global options such as an API version setting.
+
+    :param argparse.ArgumentParser parser: The parser object that has been
+        initialized by OpenStackShell.
+    """
+    return parser

nectar_osc/rating.py

@@ -0,0 +1,60 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import logging
+
+from osc_lib.command import command
+from osc_lib import utils as osc_utils
+from oslo_config import cfg
+
+
+CONF = cfg.CONF
+
+
+class ListFlavors(command.Lister):
+    """List Flavors with rating."""
+
+    log = logging.getLogger(__name__ + '.ListFlavors')
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            '--all', action='store_true', help=('Display All flavors')
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        self.log.debug('take_action(%s)', parsed_args)
+        compute_client = self.app.client_manager.compute
+        rating_client = self.app.client_manager.rating
+        flavor_kwargs = {}
+        if parsed_args.all:
+            flavor_kwargs['is_public'] = None
+        flavors = compute_client.flavors.list(**flavor_kwargs)
+        groups = rating_client.rating.hashmap.get_group()['groups']
+        group_id = None
+        for g in groups:
+            if g.get('name') == 'instance_uptime_flavor_id':
+                group_id = g.get('group_id')
+                break
+        mappings = rating_client.rating.hashmap.get_group_mappings(
+            group_id=group_id
+        )['mappings']
+        mappings = {m.get('value'): m.get('cost') for m in mappings}
+        for f in flavors:
+            f.rate = mappings.get(f.id)
+        columns = ['id', 'name', 'rate']
+        return (
+            columns,
+            (osc_utils.get_item_properties(f, columns) for f in flavors),
+        )

nectar_osc/security.py

@@ -0,0 +1,315 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import logging
+import sys
+
+from novaclient import exceptions as n_exc
+from osc_lib.command import command
+from oslo_config import cfg
+
+from nectar_osc import compute
+from nectar_osc import freshdesk
+from nectar_osc import identity
+from nectar_osc import network
+
+
+CONF = cfg.CONF
+
+
+class SecurityCommand(command.Command):
+    """security top class"""
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            '--no-dry-run', action='store_true', help=('Really perform action')
+        )
+        parser.add_argument(
+            'id', metavar='<instance_id>', help=('Instance uuid')
+        )
+
+        return parser
+
+
+class LockInstance(SecurityCommand):
+    """pause and lock an instance"""
+
+    log = logging.getLogger(__name__ + '.Security.LockInstance')
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            '--cc',
+            metavar='<email>',
+            help=('Extra email address to add to cc list'),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        self.log.debug('take_action(%s)', parsed_args)
+        clients = self.app.client_manager
+
+        fd = freshdesk.get_client()
+
+        if not parsed_args.no_dry_run:
+            print('Running in dry-run mode (use --no-dry-run to action)')
+
+        try:
+            instance = clients.compute.servers.get(parsed_args.id)
+        except n_exc.NotFound:
+            print(f'Instance {parsed_args.id} not found')
+            sys.exit(1)
+
+        # Pause and lock instance
+        if not parsed_args.no_dry_run:
+            if instance.status != 'ACTIVE':
+                print(f'Instance state {instance.status}, will not pause')
+            else:
+                print(f'Would pause and lock instance {instance.id}')
+        else:
+            if instance.status != 'ACTIVE':
+                print(
+                    f'Instance not in ACTIVE state ({instance.status}), '
+                    'skipping'
+                )
+            else:
+                print(f'Pausing instance {instance.id}')
+                instance.pause()
+
+            print(f'Locking instance {instance.id}')
+            instance.lock()
+
+        # Process ticket
+        ticket_id = None
+        ticket_url = instance.metadata.get('security_ticket')
+        if ticket_url:
+            print(f'Found existing ticket: {ticket_url}')
+            ticket_id = int(ticket_url.split('/')[-1])
+
+            if not parsed_args.no_dry_run:
+                print(f'Would set ticket #{ticket_id} status to open/urgent')
+            else:
+                # Set ticket status, priority and reply
+                print('Replying to ticket with action details')
+                action = (
+                    f'Instance <b>{instance.name} ({instance.id})</b>'
+                    ' has been <b>paused and '
+                    'locked</b>'
+                )
+                fd.comments.create_reply(ticket_id, action)
+                print(f'Setting ticket #{ticket_id} status to open/urgent')
+                fd.tickets.update_ticket(ticket_id, status=6, priority=4)
+        else:
+            project = clients.identity.projects.get(instance.tenant_id)
+            user = clients.identity.users.get(instance.user_id)
+            email = user.email or 'no-reply@nectar.org.au'
+            name = getattr(user, 'full_name', email)
+            cc_emails = identity.get_tenant_managers_emails(
+                clients.identity, instance
+            )
+            if parsed_args.cc:
+                cc_emails.append(parsed_args.cc)
+
+            # Create ticket if none exist, and add instance info
+            subject = (
+                f'Security incident for instance {instance.name} '
+                f'({instance.id})'
+            )
+            body = '<br />\n'.join(
+                [
+                    'Dear Nectar Research Cloud User, ',
+                    '',
+                    '',
+                    'We have reason to believe that cloud instance: '
+                    f'<b>{instance.name} ({instance.id})</b>',
+                    f'in the project <b>{project.name}</b>',
+                    f'created by <b>{email}</b>',
+                    'has been involved in a security incident, ',
+                    'and has been locked.',
+                    '',
+                    'We have opened this helpdesk ticket to track the ',
+                    'details and the progress of the resolution of this ',
+                    'issue.',
+                    '',
+                    'Please reply to this email if you have any questions or ',
+                    'concerns.',
+                    '',
+                    'Thanks, ',
+                    'Nectar Research Cloud Team',
+                ]
+            )
+
+            if not parsed_args.no_dry_run:
+                print('Would create ticket with details:')
+                print(f'  To:      {name} <{email}>')
+                print(f'  CC:      {", ".join(cc_emails)}')
+                print(f'  Subject: {subject}')
+
+                print('Would add instance details to ticket:')
+                print(compute.show_instance(clients, instance.id))
+                print(
+                    network.show_instance_security_groups(clients, instance.id)
+                )
+            else:
+                print('Creating new Freshdesk ticket')
+                ticket = fd.tickets.create_outbound_email(
+                    name=name,
+                    description=body,
+                    subject=subject,
+                    email=email,
+                    cc_emails=cc_emails,
+                    email_config_id=CONF.freshdesk.email_config_id,
+                    group_id=CONF.freshdesk.group_id,
+                    priority=4,
+                    status=2,
+                    tags=['security'],
+                )
+                ticket_id = ticket.id
+
+                # Use friendly domain name if using prod
+                if fd.domain == 'dhdnectar.freshdesk.com':
+                    domain = 'support.ehelp.edu.au'
+                else:
+                    domain = fd.domain
+
+                ticket_url = f'https://{domain}/helpdesk/tickets/{ticket_id}'
+                clients.compute.servers.set_meta(
+                    instance.id, {'security_ticket': ticket_url}
+                )
+                print(f'Ticket #{ticket_id} has been created: {ticket_url}')
+
+                # Add a private note with instance details
+                print('Adding instance information to ticket')
+                instance_info = compute.show_instance(
+                    clients, instance.id, style='html'
+                )
+                sg_info = network.show_instance_security_groups(
+                    clients, instance.id, style='html'
+                )
+                body = '<br/><br/>'.join([instance_info, sg_info])
+                fd.comments.create_note(ticket_id, body)
+
+
+class UnlockInstance(SecurityCommand):
+    """unlock an instance"""
+
+    log = logging.getLogger(__name__ + '.Security.UnlockInstance')
+
+    def take_action(self, parsed_args):
+        self.log.debug('take_action(%s)', parsed_args)
+        clients = self.app.client_manager
+
+        fd = freshdesk.get_client()
+
+        """unlock an instance"""
+        if not parsed_args.no_dry_run:
+            print('Running in dry-run mode (use --no-dry-run to action)')
+
+        try:
+            instance = clients.compute.servers.get(parsed_args.id)
+        except n_exc.NotFound:
+            print(f'Instance {parsed_args.id} not found')
+            sys.exit(1)
+
+        ticket_id = None
+        ticket_url = instance.metadata.get('security_ticket')
+        if ticket_url:
+            print(f'Found ticket: {ticket_url}')
+            ticket_id = int(ticket_url.split('/')[-1])
+        else:
+            if parsed_args.no_dry_run is True:
+                print('No ticket found in instance metadata!')
+                sys.exit(1)
+
+        if instance.status == 'PAUSED':
+            if not parsed_args.no_dry_run:
+                print(f'Would unpause and unlock instance {instance.id}')
+                print('Would reply to ticket')
+                print('Would resolve ticket')
+            else:
+                print(f'Unpausing instance {instance.id}')
+                instance.unpause()
+
+                print(f'Unlocking instance {instance.id}')
+                instance.unlock()
+
+                # Add reply to user
+                print('Replying to ticket with action details')
+                action = (
+                    f'Instance <b>{instance.name} ({instance.id})</b>'
+                    ' has been <b>unpaused and unlocked</b>'
+                )
+                fd.comments.create_reply(ticket_id, action)
+
+                # Set ticket status=resolved
+                print(f'Setting ticket #{ticket_id} status to resolved')
+                fd.tickets.update_ticket(ticket_id, status=4)
+        else:
+            print(f"Instance {ticket_id} is not locked, won't unlock")
+
+
+class DeleteInstance(SecurityCommand):
+    """delete an instance"""
+
+    log = logging.getLogger(__name__ + '.Security.DeleteInstance')
+
+    def take_action(self, parsed_args):
+        self.log.debug('take_action(%s)', parsed_args)
+        clients = self.app.client_manager
+
+        fd = freshdesk.get_client()
+
+        """delete an instance"""
+        if not parsed_args.no_dry_run:
+            print('Running in dry-run mode (use --no-dry-run to action)')
+
+        try:
+            instance = clients.compute.servers.get(parsed_args.id)
+        except n_exc.NotFound:
+            print(f'Instance {parsed_args.id} not found')
+            sys.exit(1)
+
+        ticket_id = None
+        ticket_url = instance.metadata.get('security_ticket')
+        if ticket_url:
+            print(f'Found ticket: {ticket_url}')
+            ticket_id = int(ticket_url.split('/')[-1])
+        else:
+            if parsed_args.no_dry_run is True:
+                print('No ticket found in instance metadata!')
+                sys.exit(1)
+
+        # DELETE!!!
+        if instance.status == 'PAUSED':
+            if not parsed_args.no_dry_run:
+                print(f'Would delete instance {instance.id}')
+                print('Would reply to ticket')
+                print('Would resolve ticket')
+            else:
+                print(f'Deleting instance {instance.id})')
+                instance.delete()
+
+                # Add reply to user
+                print('Updating ticket with action')
+                action = (
+                    f'Instance <b>{instance.name} ({instance.id})</b>'
+                    ' has been <b>deleted.</b>'
+                )
+                fd.comments.create_reply(ticket_id, action)
+
+                # Set ticket status=resolved
+                print(f'Resolving ticket #{ticket_id}')
+                fd.tickets.update_ticket(ticket_id, status=4)
+        else:
+            print(f"Instance {instance.id} is not locked, won't delete")

nectar_osc/show.py

@@ -0,0 +1,69 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import logging
+import sys
+
+from novaclient import exceptions as n_exc
+from osc_lib.command import command
+
+from nectar_osc import compute
+from nectar_osc import network
+
+
+class ShowCommand(command.Command):
+    """show top class"""
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'id', metavar='<server>', help=('Server (name or ID)')
+        )
+
+        return parser
+
+
+class ShowInstance(ShowCommand):
+    """show instance details"""
+
+    log = logging.getLogger(__name__ + '.Show.ShowInstance')
+
+    def take_action(self, parsed_args):
+        self.log.debug('take_action(%s)', parsed_args)
+        clients = self.app.client_manager
+
+        try:
+            instance = clients.compute.servers.get(parsed_args.id)
+        except n_exc.NotFound:
+            print(f'Server {parsed_args.id} not found')
+            sys.exit(1)
+
+        print(compute.show_instance(clients, instance.id))
+
+
+class ShowSecuritygroups(ShowCommand):
+    """show instance security group details"""
+
+    log = logging.getLogger(__name__ + '.Show.ShowSecuritygroups')
+
+    def take_action(self, parsed_args):
+        self.log.debug('take_action(%s)', parsed_args)
+        clients = self.app.client_manager
+
+        try:
+            instance = clients.compute.servers.get(parsed_args.id)
+        except n_exc.NotFound:
+            print(f'Server {parsed_args.id} not found')
+            sys.exit(1)
+
+        print(network.show_instance_security_groups(clients, instance.id))

nectar_osc-1.0.0.dist-info/LICENSE

@@ -0,0 +1,176 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+

nectar_osc-1.0.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: nectar-osc
+Version: 1.0.0
+Summary: OpenStack client plugin for misc Nectar tooling
+Home-page: https://github.com/NeCTAR-RC/python-nectar-osc
+Author: ARDC Nectar Cloud Services
+Author-email: coreservices@ardc.edu.au
+License: Apache-2.0
+Keywords: varroa
+Classifier: Environment :: OpenStack
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE
+Requires-Dist: oslo.config
+Requires-Dist: oslo.utils
+Requires-Dist: osc-lib
+Requires-Dist: python-freshdesk
+Requires-Dist: python-openstackclient
+Requires-Dist: python-neutronclient
+Requires-Dist: pbr>=3.0.0
+
+# Nectar Openstack Client Plugin
+
+Provides some helpers for nectar cloud.
+

nectar_osc-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+nectar_osc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nectar_osc/compute.py,sha256=9q9OXimI6Ae8_P6koRKksJKoAumCSXPLDaYwf_y-4R0,3809
+nectar_osc/config.py,sha256=2I1_6O0G-G5ntyAjZ2awh3Q_oPe36blVxxMRi4_-mR0,1798
+nectar_osc/freshdesk.py,sha256=WzH6PHxFcyNz5LWQf2jT4zUdPNJwVSV2409c6ohdyA8,1659
+nectar_osc/identity.py,sha256=1D7h8aS4lWnXx9xZ3OYCRpwL21JuB-JAvokwx5lQ6Y4,1030
+nectar_osc/network.py,sha256=CzTdzyGnkIi1oa_Q8A2aGFRVztjBRybbTvWhV_wGSzI,3789
+nectar_osc/plugin.py,sha256=zo9jdrhdKqzkE1jH4Y9UhwY1lCERWKg632-LsBWVfrY,1549
+nectar_osc/rating.py,sha256=5nez4Le3HgvEgMshyvPRvj-QFhji1k9I_0XlDa40AMA,2084
+nectar_osc/security.py,sha256=_UVAzNU_qjS-p702L_DBt0GQ-WBKO4cUHpdkmEcKItU,11554
+nectar_osc/show.py,sha256=OLfxysAv8WgG_jAuuTiYIKi4aDId-Wg0-kMIRx0m6BQ,2093
+nectar_osc-1.0.0.dist-info/LICENSE,sha256=XfKg2H1sVi8OoRxoisUlMqoo10TKvHmU_wU39ks7MyA,10143
+nectar_osc-1.0.0.dist-info/METADATA,sha256=60YwjSaiAccBiHv8abQXbKrFxCssWoSV1n2wsFOrr_o,1093
+nectar_osc-1.0.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+nectar_osc-1.0.0.dist-info/entry_points.txt,sha256=heMhpO1n6fFVP4mas8DKUjwHakpuMgjD3ehJ0WLTLQE,511
+nectar_osc-1.0.0.dist-info/pbr.json,sha256=E-9l_DOHMyCWoh8QgZAvuvgU5FjQXlaXqe_H4KPOt6s,46
+nectar_osc-1.0.0.dist-info/top_level.txt,sha256=WFMtCn5VNuvseahg_hiry5fqRoLwnsnHQvQuHAj4cmQ,11
+nectar_osc-1.0.0.dist-info/RECORD,,

nectar_osc-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nectar_osc-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,13 @@
+[openstack.cli.extension]
+nectar = nectar_osc.osc.plugin
+
+[openstack.nectar.v1]
+nectar flavor list = nectar_osc.rating:ListFlavors
+nectar security instance delete = nectar_osc.security:DeleteInstance
+nectar security instance lock = nectar_osc.security:LockInstance
+nectar security instance unlock = nectar_osc.security:UnlockInstance
+nectar server securitygroups = nectar_osc.show:ShowSecuritygroups
+nectar server show = nectar_osc.show:ShowInstance
+
+[oslo.config.opts]
+nectar_osc = nectar_osc.config:list_opts

nectar_osc-1.0.0.dist-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "c7e762b", "is_release": true}

nectar_osc-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nectar_osc