Esempio n. 1
0
 def __init__(self):
     self.team_name = config.get('team_config', 'team_name')
     self.instances = config.get('instance_config',
                                 'instances').replace(' ', '').split(',')
     self.num_dict = {
         s.split(':')[0]: int(s.split(':')[1])
         for s in config.get('instance_config', 'number_of_solutions').
         replace(' ', '').split(',')
     }
Esempio n. 2
0
def mutate(parent: Chromosome) -> Chromosome:
    """
        Takes a child and mutates it according to mutation method in .ini file
    """
    mutation_rate = float(config.get('run_config', 'mutation_rate'))
    getattr(Mutation,
            config.get('algorithm_config',
                       'mutation').lower().strip())(Mutation(), parent,
                                                    mutation_rate)
    return parent
def mutation(parents: [Chromosome]) -> [Chromosome]:
    parent_a, parent_b = parents
    getattr(Mutation,
            config.get('algorithm_config', 'mutation').lower().strip())(
                Mutation(), parent_a,
                float(config.get('run_config', 'mutation_rate')))
    getattr(Mutation,
            config.get('algorithm_config', 'mutation').lower().strip())(
                Mutation(), parent_b,
                float(config.get('run_config', 'mutation_rate')))

    return parents
Esempio n. 4
0
    def __init__(self):
        level = "INFO"
        if config.get("CB_LOGLEVEL"):
            level = config.get("CB_LOGLEVEL")

        logging.basicConfig(
            handlers=[
                logging.FileHandler("combahton.log"),
                logging.StreamHandler()
            ],
            level=level,
            format="%(asctime)s [%(levelname)s] %(message)s"
        )
        coloredlogs.install(level=level)
Esempio n. 5
0
def crossover(parents: [Chromosome]) -> (Chromosome, Chromosome):
    """
        This function calls the required crossover method based on .ini file
    """
    parent_a, parent_b = parents

    if random.random() > float(config.get('run_config', 'crossover_rate')):
        return parents

    child_a, child_b = getattr(
        Crossover,
        config.get('algorithm_config',
                   'crossover').lower().strip())(Crossover(), parent_a,
                                                 parent_b)
    return [child_a, child_b]
Esempio n. 6
0
    def solve(self):
        """
            This method solves the problem using NTGA algorithm
        """
        generation_limit = int(config.get('run_config', 'generation_limit'))
        self.generate_initial_population()

        new_population = []
        print("Generation limit:", str(generation_limit))
        for i in range(generation_limit):
            print("generation: ", i)
            self.population = self.evaluate(self.population)
            self.non_dominated_set.adds(self.population)

            while len(new_population) < self.population_size:
                parents = self.selection()
                children = mutation(crossover(parents))

                for child in children:
                    count = 0
                    while (child in new_population) or children[0] == children[1]:
                        count += 1
                        mutate(child)
                        if count > 100:
                            break

                new_population += children

            self.population = new_population
            new_population = []

        return self.non_dominated_set
Esempio n. 7
0
def mutation(parents: [Chromosome]) -> [Chromosome]:
    """
        Gets a list of parents and mutates the children according to mutation method in .ini file
    """
    parent_a, parent_b = parents
    mutation_rate = float(config.get('run_config', 'mutation_rate'))
    getattr(Mutation,
            config.get('algorithm_config',
                       'mutation').lower().strip())(Mutation(), parent_a,
                                                    mutation_rate)
    getattr(Mutation,
            config.get('algorithm_config',
                       'mutation').lower().strip())(Mutation(), parent_b,
                                                    mutation_rate)

    return parents
def crossover(parents: [Chromosome]) -> (Chromosome, Chromosome):
    parent_a, parent_b = parents
    child_a, child_b = getattr(
        Crossover,
        config.get('algorithm_config',
                   'crossover').lower().strip())(Crossover(), parent_a,
                                                 parent_b)
    return [child_a, child_b]
Esempio n. 9
0
    def request(self, **kwargs):
        """Send a request to api.combahton.net/v2 using kwargs"""
        post_data = {
            "email": self.auth_user,
            "secret": self.auth_secret
        }

        for key, value in kwargs.items():
            post_data[key] = value

        l7_cookie = config.get("LAYER7_VALIDATE") if config.get("LAYER7_VALIDATE") else ""

        logger.debug("Sending request to {scope:s} (cookie: {cookie:s}) with params: {param:s}".format(scope = self.scope, cookie = l7_cookie, param = json.dumps(post_data)))
        response = requests.post(self.scope, json=post_data, headers=self.headers, cookies={ 'layer7-validate': l7_cookie })
        if "Authentication required" in response.text:
            cookie = r_l7_cookie.search(response.text)
            with open(".env", "a+") as file:
                file.write("\nLAYER7_VALIDATE={cookie:s}".format(cookie=cookie[1]))
            return { "status": "layer7_challenge" }

        if response.headers["Content-Type"] == "application/pdf":
            return response

        logger.debug(response.text)
        try:
            logger.debug("Parsing response as JSON")
            return json.loads(response.text)
        except (json.JSONDecodeError, ValueError):
            try:
                logger.debug("Trying to fix malformed json")
                json_fix = self.try_fix_json(response.text)
                if json_fix:
                    logger.debug("JSON has been fixed.")
                    return json_fix
                else:
                    logger.debug("JSON could not be parsed. Falling back to plain text")
                    return response.text
            except ValueError:
                logger.debug("JSON could not be parsed. Falling back to plain text")
                return response.text
Esempio n. 10
0
    def solve(self):
        generation_limit = int(config.get('run_config', 'generation_limit'))
        self.generate_initial_population()

        new_population = []

        for i in range(generation_limit):
            self.population = self.evaluate(self.population)
            self.non_dominated_set.adds(self.population)

            while len(new_population) < self.population_size:
                parents = self.selection()
                children = mutation(crossover(parents))

                for child in children:
                    while (child
                           in new_population) or children[0] == children[1]:
                        child.mutate()

                new_population += children

            self.population = new_population

        return self.non_dominated_set
Esempio n. 11
0
from ftplib import FTP
from pathlib import Path
from tqdm import tqdm
import click

from helpers.config import config  # pylint: disable=import-error,no-name-in-module
from helpers.logger import Logger  # pylint: disable=import-error,no-name-in-module

log = Logger().get_logger()


@click.command(name="iso-upload")
@click.argument("contract", type=click.INT)
@click.argument("image", type=click.Path(exists=True))
@click.argument("password",
                type=click.STRING,
                default=config.get("CB_ISOFTP_PWD"))
def iso(contract, password, image):
    """Cloud: Manage / Upload Private ISO Images
    Either provide the password, or set it inside an environment variable: CB_ISOFTP_PWD"""
    image = Path(image)
    host = "isoshare-ffm2.combahton.net"
    user = "******".format(contract)
    with FTP(host = host, user = user, passwd = password) as ftp, \
        open(image, 'rb') as file, \
        tqdm(unit = 'B', unit_scale = True, leave = False, miniters = 1, desc = 'Uploading {}...'.format(image.name), total = image.stat().st_size) as tqdm_instance:
        ftp.storbinary(f'STOR {image.name}',
                       file,
                       callback=lambda sent: tqdm_instance.update(len(sent)))
Esempio n. 12
0
 def __init__(self, problem: Problem) -> None:
     self.xyz = 1
     self.problem = problem
     self.population_size = int(config.get('run_config', 'population_size'))
     self.non_dominated_set = NonDominatedSet()
     self.population = []
Esempio n. 13
0
from helpers.config import config  # pylint: disable=import-error,no-name-in-module

api = APIv2()
log = Logger().get_logger()


@click.group()
def layer7():
    """Methods to access and modify the layer 7 filter settings"""


@click.command(name="set-routing")
@click.argument("routing_type",
                type=click.Choice(
                    ['only_on', 'only_off', 'activate', 'deactivate']))
@click.argument("ipv4", default=config.get("CB_DEFAULT_IP"))
def l7_routing(routing_type, ipv4):
    """Set the Layer 7 routing mode of the specified IPv4
    Valid routing types are only_on, only_off, activate, deactivate"""
    try:
        ipaddr = str(ipaddress.ip_address(ipv4))
        response = api.request(component="antiddos",
                               method="layer7",
                               action="routing",
                               routing=routing_type,
                               ipaddr=ipaddr)
        if "status" in response:
            res_status = api.parse_status(response["status"])
            log.log(res_status["level"], res_status["message"])
        else:
            log.fatal("An unknown error occured.")
Esempio n. 14
0
import sys
import click

from commands.v2.antiddos.__main__ import antiddos as antiddos_v2
from commands.v2.cloud.__main__ import cloud as cloud_v2
from commands.v2.customer.__main__ import customer as customer_v2
from commands.v2.ipaddr.__main__ import ipaddr as ipaddr_v2
from commands.misc.__main__ import misc

from helpers.config import config
from helpers.logger import Logger
from helpers.version import check_version, __version__

if not config.get("CB_DEBUG"):
    sys.tracebacklimit = 0

log = Logger().get_logger()


@click.group(
    help=
    "combahton-cli Version: {version:s} \n\nSimple CLI Interface to interact with combahton Services"
    .format(version=__version__))
def cli():
    pass


cli.add_command(misc)


def populate_commands_v2():
Esempio n. 15
0
import click
from tabulate import tabulate # pylint: disable=import-error

from helpers.config import config # pylint: disable=import-error,no-name-in-module
from helpers.api import APIv2 # pylint: disable=import-error,no-name-in-module
from helpers.logger import Logger # pylint: disable=import-error,no-name-in-module

api = APIv2()
log = Logger().get_logger()

@click.group()
def ipaddr():
    """Provides access to ip address details from combahton.net"""

@click.command(name="get-rdns")
@click.argument("address", default=config.get("CB_DEFAULT_IP"))
@click.option("-f", "--format", "output_format", type=click.Choice(['table','json'], case_sensitive=False), default='table')
def ipaddr_get_rdns(address,output_format):
    """View details about the specified ip address. If you do not specify an IP address, CB_DEFAULT_IP will be used."""
    action = "none"
    try:
        address = ipaddress.ip_address(address)
        if isinstance(address, ipaddress.IPv4Address):
            action = "ipv4"
        elif isinstance(address, ipaddress.IPv6Address):
            action = "ipv6"

        response = api.request(component = "ipaddr", method="view", action=action, ipaddr = str(address))
        if "status" in response:
            res_status = api.parse_status(response["status"])
            if res_status:
Esempio n. 16
0
 def __init__(self):
     self.scope = "https://api.combahton.net/v2"
     self.auth_user = config.get("CB_AUTH_USER")
     self.auth_secret = config.get("CB_AUTH_SECRET")