Exemplo n.º 1
0
    def post(self, action_type: str):
        """
        request.data : {
            'params': {...}
        }
        :param action_type:
        :return:
        """
        connector = get_connector()
        data = request.get_json()
        action_type = action_type.lower()

        if 'params' not in data: return {"message": "NOT OK"}
        params = data['params']

        if action_type == "horizontal_scaling":
            self.horizontal_scaling(connector, params)
            return {"message": "OK"}

        commands = {}

        if action_type == "vertical_scaling":
            commands['vertical_scaling'] = self.vertical_scaling(params)
        if action_type == "network": commands["network"] = self.network(params)
        if action_type == "stress":
            commands["stress"] = self.stress(connector, params)
        if action_type == "command": commands["command"] = self.command(params)
        if action_type == "links": commands["links"] = self.links(params)

        Communicator(get_connector()).agents__perform_action(
            commands, **params)

        return {"message": "OK"}
Exemplo n.º 2
0
 def post(self, service):
     commands, res = {'links': {'network': 'all'}}, []
     for instance_type in service.split("|"):
         res.append(
             Communicator(get_connector()).agents__perform_action(
                 commands, instance_type=instance_type))
     return {"message": "OK"}
Exemplo n.º 3
0
def connector_callback(request, connector_name):
    connector = connectors.get_connector(connector_name)
    uid, name, access_token, expire_time = connector.login_callback(request)
    request.session['%s_access_token' % connector_name] = access_token

    if request.user.is_anonymous():
        try:
            connection = Connection.objects.get(connector_id=uid, connector=connector_name)
            if connection.user.connector:
                credential = connection.user.username
                user = authenticate(credential=credential, password=credential)
            else:
                user = authenticate(connection_id=connection.id)

        except Connection.DoesNotExist:
            seed = os.urandom(40)
            credential = hashlib.sha1(seed).hexdigest()
            user = User.objects.create_user(username=credential, email=credential, password=credential)
            user.connector = connector_name
            user.save()
            user = authenticate(credential=credential, password=credential)
            Connection.objects.create(user=user, connector=connector_name, connector_id=uid, connector_username=name)

        auth_login(request, user)
        return redirect(index)

    try:
        Connection.objects.get(user=request.user, connector=connector_name)
        return redirect(connector_detail, connector_name=connector_name, uid=uid)

    except Connection.DoesNotExist:
        Connection.objects.create(user=request.user, connector=connector_name,
            connector_id=uid, connector_username=name)
        return redirect(settings)
Exemplo n.º 4
0
def print_sqoop_cmds(task):
    with get_connector(task.source) as conn:
        to_import = get_tables_to_import(conn, task)
        for table in sorted(to_import, key=lambda tbl: tbl.name):
            columns = conn.get_columns(table)
            cmd = SqoopCmd(task, table, columns)
            print cmd.as_string()
Exemplo n.º 5
0
 def delete(self):
     """ Remove a Fogify deployment"""
     Status.update_config('submit_delete')
     Annotation.create(Annotation.TYPES.STOP.value)
     connector = get_connector()
     t = AsyncTask(self, 'remove', [connector])
     t.start()
     return {"message": "The topology is down."}
Exemplo n.º 6
0
def print_schema(task):
    with get_connector(task.source) as conn:
        to_import = get_tables_to_import(conn, task)
        for table in to_import:
            print '\n=== {0}.{1} ==='.format(task.source['db'], table[0])
            columns = conn.get_columns(table)
            for c in columns:
                print '{0}: {1}'.format(c.name, c.type)
Exemplo n.º 7
0
 def get(self):
     """ Returns the current status of the fogify deployment"""
     infrastructure_status = Status.query.filter_by(
         name="infrastructure").first()
     if infrastructure_status and infrastructure_status.value == 'error':
         raise exceptions.APIException(
             'The deployment is failed. Please check the logs of the Fogify Controller.'
         )
     connector = get_connector()
     return connector.return_deployment()
Exemplo n.º 8
0
    def get(self, service):
        if service.lower() != "controller-properties":
            return {"message": "error"}

        try:
            return {"credits": get_connector().get_manager_info()}
        except Exception as ex:
            logging.error(
                "The system does not return the credits of the manager.",
                exc_info=True)
            return {"credits": ""}
Exemplo n.º 9
0
    def get(self):
        """ Returns the stored monitoring data """
        try:
            query = ""
            from_timestamp = request.args.get('from_timestamp')
            to_timestamp = request.args.get('to_timestamp')
            service = request.args.get('service')
            query += "from_timestamp=" + from_timestamp + "&" if from_timestamp else ""
            query += "to_timestamp=" + to_timestamp + "&" if to_timestamp else ""
            query += "service=" + service if service else ""

            return Communicator(get_connector()).agents__get_metrics(query)

        except Exception as e:
            return {"Error": "{0}".format(e)}
Exemplo n.º 10
0
 def get(self):
     """ Returns the stored monitoring data """
     try:
         query = ""
         from_timestamp = request.args.get('from_timestamp')
         to_timestamp = request.args.get('to_timestamp')
         service = request.args.get('service')
         packet_type = request.args.get('packet_type')
         query += "from_timestamp=" + from_timestamp + "&" if from_timestamp else ""
         query += "to_timestamp=" + to_timestamp + "&" if to_timestamp else ""
         query += "service=" + service if service else ""
         query += "packet_type=" + packet_type if packet_type else ""
         return Communicator(get_connector()).agents__get_packets(query)
     except Exception as e:
         logging.error("The system could not return the sniffer's data.",
                       exc_info=True)
         return {"Error": "{0}".format(e)}
Exemplo n.º 11
0
    def post(self):
        """ Introduce a new deployment to the fogify"""

        path = os.getcwd() + app.config['UPLOAD_FOLDER']

        Annotation.create(Annotation.TYPES.START.value)

        if 'file' in request.files:
            file = request.files['file']
            if not os.path.exists(path): os.mkdir(path)
            file.save(os.path.join(path, "docker-compose.yaml"))
        f = open(os.path.join(path, "docker-compose.yaml"), "r")
        infra = yaml.load(f)

        model = FogifyModel(infra)

        try:
            connector = get_connector(model=model)
            controller_response = connector.generate_files()
            yaml.dump(controller_response,
                      open(path + "fogified-swarm.yaml", 'w'),
                      default_flow_style=False)
            networks = model.generate_network_rules()
        except Exception as ex:
            logging.error(
                "An error occurred on monitoring view. The metrics did not retrieved.",
                exc_info=True)
            raise exceptions.APIException(
                "Fogify could not generate the orchestrator files."
                "Please check your fogify model again.")

        yaml.dump(networks,
                  open(path + "fogified-network.yaml", 'w'),
                  default_flow_style=False)

        t = AsyncTask(self, 'submition', [connector, path, model.all_networks])
        t.start()

        return {
            "message": "OK",
            "swarm": controller_response,
            "networks": networks
        }
Exemplo n.º 12
0
    def post(self, name):
        path = os.getcwd() + app.config['UPLOAD_FOLDER']

        if 'file' in request.files:
            file = request.files['file']
            if not os.path.exists(path): os.mkdir(path)
            file.save(os.path.join(path, "rttdata.txt"))

        res = NetworkController.generate_network_distribution(path, name)
        lines = res.split("\n")
        res = {}
        for line in lines:
            line_arr = line.split("=")
            if len(line_arr) == 2:
                res[line_arr[0].strip()] = line_arr[1].strip()

        Communicator(get_connector()).agents__disseminate_net_distribution(
            name, open(os.path.join(path, name + ".dist"), 'rb'))

        return {"generated-distribution": res}
Exemplo n.º 13
0
 def delete(self):
     """ Removes the stored monitoring data """
     return Communicator(get_connector()).agents__delete_packets()
Exemplo n.º 14
0
    def __init__(self, args, app):
        """
        It instantiates the agent and starts the API server
        :param args:
        :param app:
        """
        db_path = os.getcwd() + '/agent_database.db'

        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + db_path

        Agent.db = SQLAlchemy(app)
        if os.path.exists(db_path): os.remove(db_path)
        os.mknod(db_path)

        app.config['UPLOAD_FOLDER'] = "/current_agent/"
        os.environ['UPLOAD_FOLDER'] = "/current_agent/"
        if not os.path.exists(os.getcwd() + app.config['UPLOAD_FOLDER']):
            os.mkdir(os.getcwd() + app.config['UPLOAD_FOLDER'])

        connector = get_connector()
        app.config['CONNECTOR'] = connector
        node_labels = {}

        if 'LABELS' in os.environ:
            node_labels = {
                i.split(":")[0]: i.split(":")[1]
                for i in os.environ['LABELS'].split(",")
                if len(i.split(":")) == 2
            }

        node_labels.update(HostInfo.get_all_properties())
        connector.inject_labels(
            node_labels,
            HOST_IP=os.environ['HOST_IP'] if 'HOST_IP' in os.environ else None)

        from utils.monitoring import MetricCollector
        from agent.views import MonitoringAPI, ActionsAPI, TopologyAPI, DistributionAPI, SnifferAPI

        # Add the api routes
        app.add_url_rule('/topology/',
                         view_func=TopologyAPI.as_view('Topology'))
        app.add_url_rule('/monitorings/',
                         view_func=MonitoringAPI.as_view('Monitoring'))
        app.add_url_rule('/actions/', view_func=ActionsAPI.as_view('Action'))
        app.add_url_rule('/packets/', view_func=SnifferAPI.as_view('Packet'))
        app.add_url_rule(
            '/generate-network-distribution/<string:name>/',
            view_func=DistributionAPI.as_view('NetworkDistribution'))

        # The thread that runs the monitoring agent
        metricController = MetricCollector()
        metricControllerTask = AsyncTask(metricController, 'start_monitoring',
                                         [args.agent_ip, connector, 5])
        metricControllerTask.start()

        # The thread that inspect containers and apply network QoS
        networkController = NetworkController(connector)
        networkControllerTask = AsyncTask(networkController, 'listen', [])
        networkControllerTask.start()

        self.app = app
        self.args = args
Exemplo n.º 15
0
def connector_login(request, connector_name):
    connector = connectors.get_connector(connector_name)
    return redirect(connector.login())