Ejemplo n.º 1
0
# -*- coding: utf-8 -*-

import os
import yaml
import tempfile
import os_client_config
from os_client_config import cloud_config
from heatclient.exc import HTTPBadRequest
from infra_scraper.input.base import BaseInput
from infra_scraper.utils import setup_logger

logger = setup_logger('input.openstack')


class OpenStackInput(BaseInput):

    RESOURCE_MAP = {
        'os_aggregate': {
            'resource': 'OS::Nova::Aggregate',
            'client': 'nova',
            'name': 'Aggregate',
            'icon': 'fa:cube',
        },
        'os_flavor': {
            'resource': 'OS::Nova::Flavor',
            'client': 'nova',
            'name': 'Flavor',
            'icon': 'fa:cube',
        },
        'os_floating_ip': {
            'resource': 'OS::Neutron::FloatingIP',
Ejemplo n.º 2
0
# -*- coding: utf-8 -*-

import boto3
from infra_scraper.input.base import BaseInput
from infra_scraper.utils import setup_logger

logger = setup_logger('input.aws')


class AmazonWebServicesInput(BaseInput):
    def __init__(self, **kwargs):
        self.kind = 'aws'
        self.scope = kwargs.get('scope', 'local')
        super(AmazonWebServicesInput, self).__init__(**kwargs)
        self.ec2_client = boto3.resource('ec2')
        self.s3_client = boto3.resource('s3')

    def scrape_all_resources(self):
        #        self.scrape_ec2_images()
        #        self.scrape_ec2_elastic_ips()
        self.scrape_ec2_instances()
        self.scrape_ec2_internet_gateways()
        self.scrape_ec2_subnets()
        self.scrape_ec2_vpcs()
        self.scrape_ec2_key_pairs()
        self.scrape_s3_buckets()

    def _create_relations(self):
        for resource_id, resource in self.resources.get('ec2_instance',
                                                        {}).items():
            if 'VpcId' in resource['metadata']:
Ejemplo n.º 3
0
# -*- coding: utf-8 -*-

import os
import yaml
import tempfile
import pykube
from requests.exceptions import HTTPError
from infra_scraper.input.base import BaseInput
from infra_scraper.utils import setup_logger

logger = setup_logger('input.kubernetes')


class KubernetesInput(BaseInput):
    def __init__(self, **kwargs):
        self.kind = 'kubernetes'
        self.scope = kwargs.get('scope', 'local')
        super(KubernetesInput, self).__init__(**kwargs)
        config_file, filename = tempfile.mkstemp()
        config_content = {
            'apiVersion':
            'v1',
            'clusters': [{
                'cluster': self.config['cluster'],
                'name': self.name,
            }],
            'contexts': [{
                'context': {
                    'cluster': self.name,
                    'user': self.name,
                },
Ejemplo n.º 4
0
# -*- coding: utf-8 -*-

from infra_scraper.input.saltstack import SaltStackInput
from infra_scraper.utils import setup_logger

logger = setup_logger('input.reclass')


class SaltReclassInput(SaltStackInput):
    def __init__(self, **kwargs):
        super(SaltReclassInput, self).__init__(**kwargs)
        self.kind = 'salt'

    def _create_relations(self):
        for resource_id, resource in self.resources.get('salt_job',
                                                        {}).items():
            for minion_id, result in resource['metadata'].get('Result',
                                                              {}).items():
                self._scrape_relation('on_salt_minion', resource_id, minion_id)

    def scrape_all_resources(self):
        self.scrape_minions()
        self.scrape_resources()
        self.scrape_jobs()
#        self.scrape_services()

    def scrape_resources(self):
        response = self.api.low([{
            'client': 'local',
            'expr_form': 'compound',
            'tgt': 'I@salt:master',
Ejemplo n.º 5
0
import time
from infra_scraper.utils import setup_logger, get_graph_schema

logger = setup_logger('input.base')


class BaseInput(object):
    def __init__(self, **kwargs):
        self.name = kwargs['name']
        self.config = kwargs['config']
        self.resources = {}
        self.resource_types = {}
        self.relations = {}
        self.timestamp = int(time.time())
        self._reverse_map = None
        self._schema = get_graph_schema(self.kind)

    def _create_relations(self):
        raise NotImplementedError

    def to_dict(self):
        self._create_relations()
        return {
            'name': self.name,
            'kind': self.kind,
            'timestamp': self.timestamp,
            'resource_types': self._get_resource_types(),
            'resources': self.resources,
            'relation_types': self._get_relation_types(),
            'relations': self.relations,
        }
Ejemplo n.º 6
0
import os
import importlib
import time

from infra_scraper import constructors
from infra_scraper import exceptions
from infra_scraper.utils import load_yaml_json_file, setup_logger

logger = setup_logger(__name__)

config_backend = os.environ.get('INFRA_SCRAPER_CONFIG_BACKEND', 'localfs')
config_file = os.environ.get('INFRA_SCRAPER_CONFIG_PATH',
                             '/etc/infra-scraper/config.yaml')


def _get_module(module_key):
    class_mapping = constructors.get_constructor_mapping()
    if module_key not in class_mapping:
        raise exceptions.InfraScraperException(
            "Service {module_key} is unkown. Please pass in a client"
            " constructor or submit a patch to infra scraper".format(
                module_key=module_key))
    mod_name, ctr_name = class_mapping[module_key].rsplit('.', 1)
    lib_name = mod_name.split('.')[0]
    try:
        mod = importlib.import_module(mod_name)
    except ImportError:
        raise exceptions.InfraScraperException(
            "Client for '{module_key}' was requested, but"
            " {mod_name} was unable to be imported. Either import"
            " the module yourself and pass the constructor in as an argument,"
Ejemplo n.º 7
0
# -*- coding: utf-8 -*-

import io
import python_terraform
from pydot import graph_from_dot_data
from infra_scraper.input.base import BaseInput
from infra_scraper.utils import setup_logger

logger = setup_logger('input.terraform')

relation_mapping = {
    'tf_openstack_compute_instance_v2-tf_openstack_compute_keypair_v2':
    'using_tf_key_pair',
    'tf_openstack_networking_subnet_v2-tf_openstack_networking_network_v2':
    'in_tf_net',
    'tf_openstack_compute_floatingip_associate_v2-tf_openstack_networking_floatingip_v2':
    'links_tf_floating_ip',
    'tf_openstack_networking_floatingip_v2-tf_openstack_networking_router_interface_v2':
    'links_tf_floating_ip',
    'tf_openstack_networking_router_interface_v2-tf_openstack_networking_subnet_v2':
    'in_tf_subnet',
    'tf_openstack_networking_router_interface_v2-tf_openstack_networking_router_v2':
    'links_tf_router',
    'tf_openstack_compute_instance_v2-tf_openstack_networking_network_v2':
    'in_tf_net',
    'tf_openstack_compute_floatingip_associate_v2-tf_openstack_compute_instance_v2':
    'links_tf_floating_instance',
    'tf_openstack_compute_instance_v2-tf_openstack_compute_secgroup_v2':
    'has_tf_security_group',
}
Ejemplo n.º 8
0
# -*- coding: utf-8 -*-

from pepper.libpepper import Pepper
from infra_scraper.input.base import BaseInput
from infra_scraper.utils import setup_logger

logger = setup_logger('input.salt')


class SaltStackInput(BaseInput):

    RESOURCE_MAP = {
        'salt_high_state': {
            'resource': 'high_state',
            'client': '',
            'name': 'High State',
            'icon': 'fa:cube',
        },
        'salt_job': {
            'resource': 'job',
            'client': '',
            'name': 'Job',
            'icon': 'fa:clock-o',
        },
        'salt_low_state': {
            'resource': 'low_state',
            'client': '',
            'name': 'Low State',
            'icon': 'fa:cube',
        },
        'salt_minion': {