Пример #1
0
 def __init__(self, name, ptm):
     super(ZookeeperHost, self).__init__(name, ptm)
     self.zookeeper_ips = []
     self.num_id = '1'
     self.ip = IP('', '')
     self.pid = 0
     self.configurator = ZookeeperFileConfiguration()
Пример #2
0
 def __init__(self, name, ptm):
     super(CassandraHost, self).__init__(name, ptm)
     self.cassandra_ips = []
     self.num_id = '1'
     self.init_token = ''
     self.ip = IP()
     self.configurator = CassandraFileConfiguration()
    def create_vm(self, ip, preferred_hv_host=None, preferred_name=None):
        """
        Creates a guest VM on the Physical Topology and returns the Guest
        object representing the VM as part of the virtual topology.
        :param ip: str IP Address to use for the VM (required)
        :param preferred_hv_host: str: Hypervisor to use, otherwise the least-loaded HV host is chosen.
        :param preferred_name: str: Name to use for the VM.  Otherwise one is generated.
        :return: Guest
        """
        self.physical_topology_manager.LOG.debug("Creating VM on IP: " + str(ip))
        if preferred_hv_host is None:
            # Pick the HV with the fewest running VMs
            least_busy_hv = None
            for hv in self.physical_topology_manager.hypervisors.itervalues():
                if least_busy_hv is None or least_busy_hv > hv.get_vm_count():
                    least_busy_hv = hv
            if least_busy_hv is None:
                raise ObjectNotFoundException('No suitable hypervisor found to launch VM')
            start_hv = least_busy_hv
        else:
            if preferred_hv_host not in self.physical_topology_manager.hypervisors:
                raise ObjectNotFoundException('Requested host to start VM: ' + preferred_hv_host + ' not found')
            start_hv = self.physical_topology_manager.hypervisors[preferred_hv_host]

        if preferred_name is not None:
            vm_name = preferred_name
        else:
            vm_name = 'vm_' + str(VirtualTopologyManager.global_vm_id)
            VirtualTopologyManager.global_vm_id += 1

        self.physical_topology_manager.LOG.debug("Starting VM with name: " + vm_name + " and IP: " +
                                                 str(ip) + " on hypervisor: " + start_hv.name)
        new_vm = start_hv.create_vm(vm_name)
        new_vm.create_interface('eth0', ip_list=[IP.make_ip(ip)])

        return Guest(new_vm)
Пример #4
0
 def do_extra_config_host_for_process_control(self, cfg_map):
     self.num_id = cfg_map['num_id']
     self.ip = IP.from_map(cfg_map['ip'])
Пример #5
0
class ZookeeperHost(NetNSHost):
    def __init__(self, name, ptm):
        super(ZookeeperHost, self).__init__(name, ptm)
        self.zookeeper_ips = []
        self.num_id = '1'
        self.ip = IP('', '')
        self.pid = 0
        self.configurator = ZookeeperFileConfiguration()

    def do_extra_config_from_ptc_def(self, cfg, impl_cfg):
        """
        Configure this host type from a PTC HostDef config and the
        implementation-specific configuration
        :type cfg: HostDef
        :type impl_cfg: ImplementationDef
        :return:
        """
        if len(cfg.interfaces.values()) > 0 and len(cfg.interfaces.values()[0].ip_addresses) > 0:
            self.ip = cfg.interfaces.values()[0].ip_addresses[0]

        if 'zookeeper_ips' in impl_cfg.kwargs:
            for i in impl_cfg.kwargs['zookeeper_ips']:
                self.zookeeper_ips.append(IP(i))

        if 'id' in impl_cfg.kwargs:
            self.num_id = impl_cfg.kwargs['id']

    def do_extra_create_host_cfg_map_for_process_control(self):
        return {'num_id': self.num_id, 'ip': self.ip.to_map()}

    def do_extra_config_host_for_process_control(self, cfg_map):
        self.num_id = cfg_map['num_id']
        self.ip = IP.from_map(cfg_map['ip'])

    def prepare_config(self):
        self.configurator.configure(self.num_id, self.zookeeper_ips, self.LOG)
        log_dir = '/var/log/zookeeper.' + self.num_id
        self.ptm.log_manager.add_external_log_file(FileLocation(log_dir + '/zookeeper.log'), self.num_id,
                                                   '%Y-%m-%d %H:%M:%S,%f')

    def print_config(self, indent=0):
        super(ZookeeperHost, self).print_config(indent)
        print ('    ' * (indent + 1)) + 'Num-id: ' + self.num_id
        print ('    ' * (indent + 1)) + 'Self-IP: ' + str(self.ip)
        print ('    ' * (indent + 1)) + 'Zookeeper-IPs: ' + ', '.join(str(ip) for ip in self.zookeeper_ips)

    # TODO: Add a wait_for_process_stop here (and to all hosts)
    def wait_for_process_start(self):
        # Checking Zookeeper status
        retries = 0
        max_retries = 45
        connected = False
        while not connected:
            ping_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.LOG.info('Trying to contact ZK server @' + self.ip.ip)
            try:
                ping_socket.settimeout(1)
                ping_socket.connect((self.ip.ip, 2181))
                ping_socket.send('ruok')
                if ping_socket.recv(16) == 'imok':
                    connected = True
            except Exception:
                pass
            finally:
                if not connected:
                    retries += 1
                    if retries > max_retries:
                        raise SubprocessFailedException('Zookeeper host ' + self.num_id + ' timed out while starting')
                    time.sleep(1)

    def prepare_environment(self):
        self.configurator.mount_config(self.num_id)

    def cleanup_environment(self):
        self.configurator.unmount_config()

    def control_start(self):
        self.cli.rm_files('/var/log/zookeeper')
        process = self.cli.cmd(('/usr/bin/java'
                                ' -cp /etc/zookeeper/conf:'
                                     '/usr/share/java/jline.jar:'
                                     '/usr/share/java/log4j-1.2.jar:'
                                     '/usr/share/java/xercesImpl.jar:'
                                     '/usr/share/java/xmlParserAPIs.jar:'
                                     '/usr/share/java/netty.jar:'
                                     '/usr/share/java/slf4j-api.jar:'
                                     '/usr/share/java/slf4j-log4j12.jar:'
                                     '/usr/share/java/zookeeper.jar'
                                ' -Dcom.sun.management.jmxremote'
                                ' -Dcom.sun.management.jmxremote.local.only=false'
                                ' -Dzookeeper.log.dir=/var/log/zookeeper'
                                ' -Dzookeeper.root.logger=INFO,ROLLINGFILE'
                                ' org.apache.zookeeper.server.quorum.QuorumPeerMain'
                                ' /etc/zookeeper/conf/zoo.cfg'),
                               blocking=False, shell=True)
        if process.pid == -1:
            raise SubprocessFailedException('java-zookeeper')
        real_pid = self.cli.get_parent_pids(process.pid)[-1]
        self.cli.write_to_file('/run/zookeeper/pid', str(real_pid))

    def control_stop(self):
        if self.cli.exists('/run/zookeeper/pid'):
            pid = self.cli.read_from_file('/run/zookeeper/pid')
            self.cli.cmd('kill ' + str(pid))
            self.cli.rm('/run/zookeeper/pid')
Пример #6
0
 def do_extra_config_host_for_process_control(self, cfg_map):
     self.num_id = cfg_map['num_id']
     self.my_ip = cfg_map['my_ip']
     self.unique_id = uuid.UUID('urn:uuid:' + cfg_map['uuid'])
     self.zookeeper_ips = [IP.make_ip(s) for s in cfg_map['zookeeper_ips'].split(',')]
Пример #7
0
class CassandraHost(NetNSHost):

    def __init__(self, name, ptm):
        super(CassandraHost, self).__init__(name, ptm)
        self.cassandra_ips = []
        self.num_id = '1'
        self.init_token = ''
        self.ip = IP()
        self.configurator = CassandraFileConfiguration()

    def do_extra_config_from_ptc_def(self, cfg, impl_cfg):
        """
        Configure this host type from a PTC HostDef config and the
        implementation-specific configuration
        :type cfg: HostDef
        :type impl_cfg: ImplementationDef
        :return:
        """
        if len(cfg.interfaces.values()) > 0 and len(cfg.interfaces.values()[0].ip_addresses) > 0:
            self.ip = cfg.interfaces.values()[0].ip_addresses[0]

        if 'init_token' in impl_cfg.kwargs:
            self.init_token = impl_cfg.kwargs['init_token']

        if 'cassandra_ips' in impl_cfg.kwargs:
            for i in impl_cfg.kwargs['cassandra_ips']:
                self.cassandra_ips.append(IP(i))

        if 'id' in impl_cfg.kwargs:
            self.num_id = impl_cfg.kwargs['id']

    def prepare_config(self):
        self.configurator.configure(self.num_id, self.cassandra_ips, self.init_token, self.ip)
        log_dir = '/var/log/cassandra.' + self.num_id
        self.ptm.log_manager.add_external_log_file(FileLocation(log_dir + '/system.log'), self.num_id,
                                                   '%Y-%m-%d %H:%M:%S,%f', 2)

    def print_config(self, indent=0):
        super(CassandraHost, self).print_config(indent)
        print ('    ' * (indent + 1)) + 'Num-id: ' + self.num_id
        print ('    ' * (indent + 1)) + 'Init-token: ' + self.init_token
        print ('    ' * (indent + 1)) + 'Self-IP: ' + str(self.ip)
        print ('    ' * (indent + 1)) + 'Cassandra-IPs: ' + ', '.join(str(ip) for ip in self.cassandra_ips)

    def do_extra_create_host_cfg_map_for_process_control(self):
        return {'num_id': self.num_id, 'ip': self.ip.to_map()}

    def do_extra_config_host_for_process_control(self, cfg_map):
        self.num_id = cfg_map['num_id']
        self.ip = IP.from_map(cfg_map['ip'])

    def wait_for_process_start(self):
        # Wait a couple seconds for the process to start before polling nodetool
        time.sleep(2)
        # Checking Cassandra status
        retries = 0
        max_retries = 10
        connected = False
        while not connected:
            if self.cli.cmd('nodetool -h 127.0.0.1 status', return_status=True) == 0:
                connected = True
            else:
                retries += 1
                if retries > max_retries:
                    raise SocketException('Cassandra host ' + self.num_id + ' timed out while starting')
                time.sleep(2)

    def prepare_environment(self):
        self.configurator.mount_config(self.num_id)

    def cleanup_environment(self):
        self.configurator.unmount_config()

    def control_start(self):
        self.cli.cmd('/bin/bash -c "MAX_HEAP_SIZE=128M HEAP_NEWSIZE=64M /etc/init.d/cassandra start"')

    def control_stop(self):
        self.cli.cmd("/etc/init.d/cassandra stop")