Example #1
0
def _start(options, config):
    """Start Fabric server.
    """

    # Remove temporary defaults file, which migh have left behind
    # by former runs of Fabric.
    _backup.cleanup_temp_defaults_files()

    #Configure TTL
    _setup_ttl(config)

    # Configure modules that are not dynamic loaded.
    _server.configure(config)
    _error_log.configure(config)
    _failure_detector.configure(config)

    # Load information on all providers.
    providers.find_providers()

    # Load all services into the service manager
    _services.ServiceManager().load_services(options, config)

    # Initilize the state store.
    _persistence.init_thread()

    # Check the maximum number of threads.
    _utils.check_number_threads()

    # Configure Fabric Node.
    fabric = FabricNode()
    reported = _utils.get_time()
    _LOGGER.info(
        "Fabric node version (%s) started. ",
        fabric.version,
        extra={
            'subject' : str(fabric.uuid),
            'category' : MySQLHandler.NODE,
            'type' : MySQLHandler.START,
            'reported' : reported
        }
    )
    fabric.startup = reported

    # Start the executor, failure detector and then service manager. In this
    # scenario, the recovery is sequentially executed after starting the
    # executor and before starting the service manager.
    _events.Handler().start()
    _recovery.recovery()
    _failure_detector.FailureDetector.register_groups()
    _services.ServiceManager().start()
Example #2
0
def _start(options, config):
    """Start Fabric server.
    """

    # Remove temporary defaults file, which migh have left behind
    # by former runs of Fabric.
    _backup.cleanup_temp_defaults_files()

    #Configure TTL
    _setup_ttl(config)

    # Configure modules that are not dynamic loaded.
    _server.configure(config)
    _error_log.configure(config)
    _failure_detector.configure(config)

    # Load information on all providers.
    providers.find_providers()

    # Load all services into the service manager
    _services.ServiceManager().load_services(options, config)

    # Initilize the state store.
    _persistence.init_thread()

    # Check the maximum number of threads.
    _utils.check_number_threads()

    # Configure Fabric Node.
    fabric = FabricNode()
    reported = _utils.get_time()
    _LOGGER.info("Fabric node version (%s) started. ",
                 fabric.version,
                 extra={
                     'subject': str(fabric.uuid),
                     'category': MySQLHandler.NODE,
                     'type': MySQLHandler.START,
                     'reported': reported
                 })
    fabric.startup = reported

    # Start the executor, failure detector and then service manager. In this
    # scenario, the recovery is sequentially executed after starting the
    # executor and before starting the service manager.
    _events.Handler().start()
    _recovery.recovery()
    _failure_detector.FailureDetector.register_groups()
    _services.ServiceManager().start()
Example #3
0
 def test_statistics_node(self):
     """Test node view.
     """
     # Check statistics on Fabric node.
     res = self.proxy.statistics.node()
     fabric = FabricNode()
     self.check_xmlrpc_simple(res, {
         'node_startup': str(fabric.startup),
     },
                              rowcount=1)
Example #4
0
def _start(options, config):
    """Start Fabric server.
    """
    # Configure modules that are not dynamic loaded.
    _server.configure(config)
    _error_log.configure(config)
    _failure_detector.configure(config)

    # Load all services into the service manager
    _services.ServiceManager().load_services(options, config)

    # Initilize the state store.
    _persistence.init_thread()

    # Check the maximum number of threads.
    _utils.check_number_threads()

    # Configure Fabric Node.
    fabric = FabricNode()
    reported = _utils.get_time()
    _LOGGER.info(
        "Fabric node starting.",
        extra={
            'subject' : str(fabric.uuid),
            'category' : MySQLHandler.NODE,
            'type' : MySQLHandler.START,
            'reported' : reported
        }
    )
    fabric.startup = reported

    # Start the executor, failure detector and then service manager. In this
    # scenario, the recovery is sequentially executed after starting the
    # executor and before starting the service manager.
    _events.Handler().start()
    _recovery.recovery()
    _failure_detector.FailureDetector.register_groups()
    _services.ServiceManager().start()
Example #5
0
    def execute(self):
        """Statistics on the Fabric node.

        It returns information on the Fabric node, specifically a list with
        the following fileds: node identification, how long it is running,
        when it was started.
        """
        fabric = FabricNode()
        node_id = fabric.uuid
        node_startup = fabric.startup
        node_uptime = _utils.get_time() - node_startup

        rset = ResultSet(names=('node_id', 'node_uptime', 'node_startup'),
                         types=(str, str, str))
        rset.append_row([node_id, node_uptime, node_startup])

        return CommandResult(None, results=rset)
Example #6
0
def _preprocess_filters(generic_filters, meta_filters):
    """Process filters.
    """
    if generic_filters:
        generic_filters = _kv_to_dict(generic_filters)
    else:
        generic_filters = {}

    if meta_filters:
        meta_filters = _kv_to_dict(meta_filters)
    else:
        meta_filters = {}

    for filters in (generic_filters, meta_filters):
        if any([key in reserved_meta for key in filters.iterkeys()]):
            raise _errors.ConfigurationError(
                "The filters option cannot have key words in the following "
                "list: %s. They are reserved for internal use." %
                (str(reserved_meta), ))

    meta_filters['mysql-fabric-group'] = str(FabricNode().group_uuid)

    return generic_filters, meta_filters
Example #7
0
def _preprocess_parameters(parameters, machine_group_uuid, provider):
    """Process paramaters.
    """
    # Check whether all parameters are expected.
    for key, value in parameters.items():
        if key not in VALID_PARAMETERS and (value is not None and value):
            raise MachineError(
                "Parameter (%s) is not in the set of possible parameters: %s.",
                key, VALID_PARAMETERS)
        elif key not in VALID_PARAMETERS:
            del parameters[key]

    # 1. Put image parameter in the appropriate format.
    if parameters['image']:
        parameters['image'] = kv_to_dict(parameters['image'])
    elif provider.default_image:
        parameters['image'] = {'name': provider.default_image}
    if not parameters['image']:
        raise MachineError("No valid image hasn't been found.")

    # 2. Put flavor parameter in the appropriate format.
    if parameters['flavor']:
        parameters['flavor'] = kv_to_dict(parameters['flavor'])
    elif provider.default_flavor:
        parameters['flavor'] = {'name': provider.default_flavor}
    if not parameters['flavor']:
        raise MachineError("No valid flavor hasn't been found.")

    # 3. Check the parameter number_machines.
    number_machines = parameters['number_machines']
    try:
        number_machines = int(number_machines)
        parameters['number_machines'] = number_machines
    except TypeError:
        number_machines = 1
        parameters['number_machines'] = number_machines
    if number_machines <= 0:
        raise MachineError(
            "Number of machines must be greater than zero (%s)." %
            (number_machines, ))

    # 4. We don't need to check the availability_zone parameter

    # 5. We don't need to check the parameter key_name parameter.

    # 6. Put the security_groups parameter in the appropriate format.
    if parameters['security_groups']:
        security_groups = parameters['security_groups'].split(',')
        parameters['security_groups'] = security_groups

    # 7. Check the private_newtwork parameter.
    private_nics = parameters['private_nics']
    private_network = parameters['private_network']
    if private_network and private_nics:
        raise ConfigurationError(
            "Can't define both private_network (%s) and private_nics "
            "parameters (%s)." % (private_network, private_nics))

    # 8. Check the public_newtwork parameter.
    public_nics = parameters['public_nics']
    public_network = parameters['public_network']
    if public_network and public_nics:
        raise ConfigurationError(
            "Can't define both public_network (%s) and public_nics "
            "parameters (%s)." % (public_network, public_nics))

    # 9. Read userdata parameter which must be a path to a file.
    if parameters['userdata']:
        try:
            src = parameters['userdata']
            userdata = open(src)
        except IOError as error:
            raise ConfigurationError("Can't open '%(src)s': %(exc)s" % {
                'src': src,
                'exc': error
            })
        parameters['userdata'] = userdata

    # 10. We don't need to check the swap parameter

    # 11. Put the block_device parameter in the appropriate format.
    if parameters['block_device']:
        raise ConfigurationError(
            "Parameter block_device is not supported yet.")

    # 12. Put the scheduler_hints parameter in the appropriate format.
    if parameters['scheduler_hints']:
        parameters['scheduler_hints'] = \
            kv_to_dict(parameters['scheduler_hints'])

    # 13. Put the private_nics parameter in the appropriate format.
    if parameters['private_nics']:
        raise ConfigurationError(
            "Parameter private_nics is not supported yet.")

    # 14. Put the public_nics parameter in the appropriate format.
    if parameters['public_nics']:
        raise ConfigurationError("Parameter public_nics is not supported yet.")

    # 15. Put meta parameter in the appropriate format.
    reserved_value = ('True',
                      str(FabricNode().version), str(FabricNode().uuid),
                      str(FabricNode().group_uuid), machine_group_uuid)
    assert len(reserved_meta) == len(reserved_value)
    if parameters['meta']:
        parameters['meta'] = kv_to_dict(parameters['meta'])
        if any(key in reserved_meta for key in parameters['meta'].iterkeys()):
            raise ConfigurationError(
                "The meta parameter cannot have keywords in the following "
                "list: %s. They are reserved for internal use." %
                (str(reserved_meta), ))
    else:
        parameters['meta'] = {}

    meta = dict(zip(reserved_meta, reserved_value))
    parameters['meta'].update(meta)