Beispiel #1
0
    def _get_defaults(manager_version):
        broker_config = BootstrapContext(ctx.bootstrap_context).broker_config()
        if not broker_config.get('broker_ssl_cert'):
            with open(get_broker_ssl_cert_path(), 'r') as f:
                broker_config['broker_ssl_cert'] = f.read()

        return {
            'version': str(manager_version),
            'broker_config': broker_config
        }
Beispiel #2
0
    def test_autoscale_from_bootstrap_context(self):
        node_id = 'node_id'
        ctx = MockCloudifyContext(
            deployment_id='test',
            node_id=node_id,
            runtime_properties={
                'ip': '192.168.0.1'
            },
            properties={
                'cloudify_agent': {
                    'user': getpass.getuser(),
                    'home_dir': self._get_home_dir(),
                    'key': KEY_FILE_PATH,
                    'distro': 'Ubuntu',
                    'distro_codename': 'trusty'
                }
            },
            bootstrap_context=BootstrapContext({
                'cloudify_agent': {
                    'min_workers': 2,
                    'max_workers': 5,
                }
            })
        )
        conf = m(ctx)
        self.assertEqual(conf['min_workers'], 2)
        self.assertEqual(conf['max_workers'], 5)

        ctx = MockCloudifyContext(
            deployment_id='test',
            node_id=node_id,
            runtime_properties={
                'ip': '192.168.0.1'
            },
            properties={
                'cloudify_agent': {
                    'user': getpass.getuser(),
                    'home_dir': self._get_home_dir(),
                    'key': KEY_FILE_PATH,
                    'distro': 'Ubuntu',
                    'distro_codename': 'trusty'
                }
            },
            bootstrap_context=BootstrapContext({
                'cloudify_agent': {
                    'min_workers': 0,
                    'max_workers': 5,
                    }
            })
        )
        conf = m(ctx)
        self.assertEqual(conf['min_workers'], 0)
        self.assertEqual(conf['max_workers'], 5)
 def get_broker_configuration(agent):
     client = CloudifyClient(
         agent['manager_ip'],
         agent['manager_port'],
     )
     bootstrap_context_dict = client.manager.get_context()
     bootstrap_context_dict = bootstrap_context_dict['context']['cloudify']
     bootstrap_context = BootstrapContext(bootstrap_context_dict)
     attributes = bootstrap_context.broker_config(
         fallback_to_manager_ip=False)
     if not attributes.get('broker_ip'):
         attributes['broker_ip'] = agent['manager_ip']
     return attributes
Beispiel #4
0
 def get_broker_configuration(agent):
     client = CloudifyClient(
         agent['manager_ip'],
         agent['manager_port'],
     )
     bootstrap_context_dict = client.manager.get_context()
     bootstrap_context_dict = bootstrap_context_dict['context']['cloudify']
     bootstrap_context = BootstrapContext(bootstrap_context_dict)
     attributes = bootstrap_context.broker_config(
         fallback_to_manager_ip=False)
     if not attributes.get('broker_ip'):
         attributes['broker_ip'] = agent['manager_ip']
     return attributes
Beispiel #5
0
    def get_broker_configuration(agent):

        client = get_rest_client(
            rest_host=agent['rest_host'],
            rest_port=agent['rest_port'],
            rest_token=agent['rest_token'],
            rest_tenant=agent['rest_tenant'],
            ssl_cert_path=agent['local_rest_cert_file'],
            bypass_maintenance_mode=agent['bypass_maintenance_mode'])

        bootstrap_context_dict = client.manager.get_context()
        bootstrap_context_dict = bootstrap_context_dict['context']['cloudify']
        bootstrap_context = BootstrapContext(bootstrap_context_dict)
        attributes = bootstrap_context.broker_config()
        return attributes
Beispiel #6
0
    def test_bootstrap_context_key_pair(self, *_):
        """tests finding a key file via bootstrap context
        """

        name = 'test_bootstrap_context_key_pair'
        private_key_dir = tempfile.mkdtemp()
        private_key_path = '{0}/{1}.pem' \
            .format(private_key_dir, name)
        open(private_key_path, 'w').close()

        cloudify_agent = MockContext()
        cloudify_agent['agent_key_path'] = private_key_path

        bootstrap_ctx = BootstrapContext({'cloudify_agent': cloudify_agent})

        ctx = MockCloudifyContext(bootstrap_context=bootstrap_ctx,
                                  node_name=name)
        current_ctx.set(ctx=ctx)

        with mock.patch(
                'cloudify_aws.utils.get_single_connected_node_by_type') \
                as mock_get_connected:
            with mock.patch('cloudify_aws.ec2.instance.Instance.__init__') \
                    as mock_instance_init:
                mock_instance_init.return_value = None
                mock_get_connected.return_value = None
                output = instance.Instance()._get_private_key('')
                self.assertEqual(private_key_path, output)
def get_remote_context(overriding_properties=None):
    blueprint_id = 'mock_blueprint'
    node_id = 'node-{0}'.format(str(uuid.uuid4())[:5])
    properties = {
        'cloudify_agent': {
            'user': '******',
            'host': VAGRANT_MACHINE_IP,
            'key': '~/.vagrant.d/insecure_private_key',
            'port': 2222
        }
    }
    if overriding_properties:
        properties.update(overriding_properties)
    return MockCloudifyContext(blueprint_id=blueprint_id,
                               node_id=node_id,
                               properties=properties,
                               runtime_properties={'ip': '127.0.0.1'},
                               bootstrap_context=BootstrapContext({
                                   'cloudify_agent': {
                                       'min_workers': 2,
                                       'max_workers': 5,
                                       'user': '******',
                                       'remote_execution_port': 2222
                                   }
                               }))
def _dump_agents(tempdir):
    ctx.send_event('Preparing agents data')
    client = get_rest_client()
    broker_config = BootstrapContext(ctx.bootstrap_context).broker_config()
    defaults = {
        'version': str(_get_manager_version(client)),
        'broker_config': broker_config
    }
    result = {}
    for deployment in client.deployments.list():
        deployment_result = {}
        for node in client.nodes.list(deployment_id=deployment.id):
            if _is_compute(node):
                node_result = {}
                for node_instance in client.node_instances.list(
                        deployment_id=deployment.id, node_name=node.id):
                    overrides = {}
                    current = node_instance.runtime_properties.get(
                        'cloudify_agent', {})
                    for k, v in defaults.iteritems():
                        overrides[k] = current.get(k, v)
                    node_result[node_instance.id] = overrides
                deployment_result[node.id] = node_result
        result[deployment.id] = deployment_result
    with open(os.path.join(tempdir, _AGENTS_FILE), 'w') as out:
        out.write(json.dumps(result))
Beispiel #9
0
 def test_ssh_port_from_config_override_bootstrap(self):
     node_id = 'node_id'
     ctx = MockCloudifyContext(
         deployment_id='test',
         node_id=node_id,
         runtime_properties={
             'ip': '192.168.0.1'
         },
         properties={
             'cloudify_agent': {
                 'home_dir': self._get_home_dir(),
                 'distro': 'Ubuntu',
                 'distro_codename': 'trusty',
                 'port': 3333
             },
         },
         bootstrap_context=BootstrapContext({
             'cloudify_agent': {
                 'agent_key_path': KEY_FILE_PATH,
                 'user': getpass.getuser(),
                 'remote_execution_port': 2222
             }
         })
     )
     conf = m(ctx)
     self.assertEqual(conf['port'], 3333)
Beispiel #10
0
 def __init__(self,
              node_id=None,
              node_name=None,
              blueprint_id=None,
              deployment_id=None,
              execution_id=None,
              properties=None,
              runtime_properties=None,
              relationships=None,
              capabilities=None,
              related=None,
              source=None,
              target=None,
              operation=None,
              resources=None,
              tenant=None,
              rest_token=None,
              provider_context=None,
              bootstrap_context=None):
     tenant = tenant or {}
     super(MockCloudifyContext, self).__init__({
         'blueprint_id': blueprint_id,
         'deployment_id': deployment_id,
         'node_id': node_id,
         'node_name': node_name,
         'node_properties': properties,
         'operation': operation,
         'tenant': tenant,
         'rest_token': rest_token
     })
     self._node_id = node_id
     self._node_name = node_name
     self._deployment_id = deployment_id
     self._execution_id = execution_id
     self._properties = properties or {}
     self._runtime_properties = \
         runtime_properties if runtime_properties is not None else {}
     self._resources = resources or {}
     self._source = source
     self._target = target
     if capabilities and not isinstance(capabilities, ContextCapabilities):
         raise ValueError("MockCloudifyContext(capabilities=?) must be "
                          "instance of ContextCapabilities, not {0}".format(
                              capabilities))
     self._related = related
     self._provider_context = provider_context or {}
     self._bootstrap_context = bootstrap_context or BootstrapContext({})
     self._mock_context_logger = setup_logger('mock-context-logger')
     if node_id:
         self._instance = MockNodeInstanceContext(
             id=node_id,
             runtime_properties=self._runtime_properties,
             relationships=relationships)
         self._capabilities = capabilities or ContextCapabilities(
             self._endpoint, self._instance)
         self._node = MockNodeContext(node_name, properties)
     if self._source is None and self._target:
         self._source = MockContext({'instance': None, 'node': None})
Beispiel #11
0
def mock_context(agent_ssl_cert,
                 agent_properties=None,
                 agent_runtime_properties=None,
                 agent_context=None,
                 **kwargs):

    agent_context = agent_context or {}
    agent_properties = agent_properties or {}
    agent_runtime_properties = agent_runtime_properties or {}

    context = {
        'node_id':
        'test_node',
        'node_name':
        'test_node',
        'blueprint_id':
        'test_blueprint',
        'deployment_id':
        'test_deployment',
        'execution_id':
        'test_execution',
        'rest_token':
        'test_token',
        'properties': {
            'cloudify_agent': agent_properties
        },
        'runtime_properties': {
            'cloudify_agent': agent_runtime_properties
        },
        'managers': [{
            'networks': {
                'default': '127.0.0.1'
            },
            'ca_cert_content': agent_ssl_cert.DUMMY_CERT,
            'hostname': 'cloudify'
        }],
        'brokers': [{
            'networks': {
                'default': '127.0.0.1'
            },
            'ca_cert_content': agent_ssl_cert.DUMMY_CERT
        }],
        'bootstrap_context':
        BootstrapContext(bootstrap_context={'cloudify_agent': agent_context}),
        'tenant': {
            'name': 'default_tenant',
            'rabbitmq_username': '******',
            'rabbitmq_password': '******',
            'rabbitmq_vhost': '/'
        }
    }
    context.update(kwargs)
    context = MockCloudifyContext(**context)
    context.installer = MagicMock()
    context._get_current_object = lambda: context
    return context
Beispiel #12
0
    def get_broker_configuration(agent):

        client = get_rest_client(
            security_enabled=agent['security_enabled'],
            rest_host=agent['rest_host'],
            rest_protocol=agent['rest_protocol'],
            rest_port=agent['rest_port'],
            rest_username=agent['rest_username'],
            rest_password=agent['rest_password'],
            rest_token=agent['rest_token'],
            verify_rest_certificate=agent['verify_rest_certificate'],
            ssl_cert_path=agent['local_rest_cert_file'],
            bypass_maintenance_mode=agent['bypass_maintenance_mode'])

        bootstrap_context_dict = client.manager.get_context()
        bootstrap_context_dict = bootstrap_context_dict['context']['cloudify']
        bootstrap_context = BootstrapContext(bootstrap_context_dict)
        attributes = bootstrap_context.broker_config()
        return attributes
 def mock_ctx(self,
              test_vars,
              test_id,
              test_deployment_id,
              runtime_properties=None):
     ctx = MockContext()
     ctx.node = MockNodeContext(properties=test_vars)
     ctx.bootstrap_context = BootstrapContext(
         common_test.BOOTSTRAP_CONTEXTS_WITHOUT_PREFIX[0])
     ctx.instance = MockNodeInstanceContext(
         id=test_id, runtime_properties=runtime_properties or {})
     ctx.deployment = mock.Mock()
     ctx.deployment.id = test_deployment_id
     ctx.type = NODE_INSTANCE
     ctx.logger = mock.Mock()
     return ctx
 def test_network_no_prefix(self):
     ctx = self._setup_ctx('network')
     for pctx in common_test.BOOTSTRAP_CONTEXTS_WITHOUT_PREFIX:
         ctx._bootstrap_context = BootstrapContext(pctx)
         self.neutron_mock.create_network.reset_mock()
         self.neutron_mock.create_network.return_value = {
             'network': {
                 'id': 'network_id',
             }
         }
         neutron_plugin.network.create(ctx)
         calls = self.neutron_mock.create_network.mock_calls
         self.assertEquals(len(calls), 1)  # Exactly one network created
         # Indexes into call[]:
         # 0 - the only call
         # 1 - regular arguments
         # 0 - first argument
         arg = calls[0][1][0]
         self.assertEquals(arg['network']['name'], 'network_name',
                           "Failed with context: " + str(pctx))
Beispiel #15
0
def get_remote_context():
    node_id = 'node-{0}'.format(str(uuid.uuid4())[:5])
    return MockCloudifyContext(node_id=node_id,
                               properties={
                                   'cloudify_agent': {
                                       'user': '******',
                                       'host': VAGRANT_MACHINE_IP,
                                       'key':
                                       '~/.vagrant.d/insecure_private_key',
                                       'port': 2222
                                   },
                               },
                               runtime_properties={'ip': '127.0.0.1'},
                               bootstrap_context=BootstrapContext({
                                   'cloudify_agent': {
                                       'min_workers': 2,
                                       'max_workers': 5,
                                       'user': '******',
                                       'remote_execution_port': 2222
                                   }
                               }))
Beispiel #16
0
def mock_context(agent_properties=None,
                 agent_runtime_properties=None,
                 agent_context=None):

    if not agent_properties:
        agent_properties = {}
    if not agent_runtime_properties:
        agent_runtime_properties = {}

    context = MockCloudifyContext(
        node_id='test_node',
        node_name='test_node',
        blueprint_id='test_blueprint',
        deployment_id='test_deployment',
        execution_id='test_execution',
        properties={'cloudify_agent': agent_properties},
        runtime_properties={'cloudify_agent': agent_runtime_properties},
        bootstrap_context=BootstrapContext(
            bootstrap_context={'cloudify_agent': agent_context}))
    setattr(context, 'installer', MagicMock())
    return context
Beispiel #17
0
 def test_bad_key_path(self):
     node_id = 'node_id'
     ctx = MockCloudifyContext(
         deployment_id='test',
         node_id=node_id,
         runtime_properties={
             'ip': '192.168.0.1'
         },
         properties={
             'cloudify_agent': {
                 'distro': 'Ubuntu',
             },
         },
         bootstrap_context=BootstrapContext({
             'cloudify_agent': {
                 'agent_key_path': 'bad_key_path',
                 'user': getpass.getuser(),
             }
         })
     )
     self.assertRaises(NonRecoverableError, m, ctx)
Beispiel #18
0
def mock_context(agent_properties=None,
                 agent_runtime_properties=None,
                 agent_context=None):

    agent_context = agent_context or {}
    agent_properties = agent_properties or {}
    agent_runtime_properties = agent_runtime_properties or {}

    context = MockCloudifyContext(
        node_id='test_node',
        node_name='test_node',
        blueprint_id='test_blueprint',
        deployment_id='test_deployment',
        execution_id='test_execution',
        rest_token='test_token',
        properties={'cloudify_agent': agent_properties},
        runtime_properties={'cloudify_agent': agent_runtime_properties},
        bootstrap_context=BootstrapContext(
            bootstrap_context={'cloudify_agent': agent_context}))
    context.installer = MagicMock()
    context._get_current_object = lambda: context
    return context
Beispiel #19
0
 def test_ssh_port_default(self):
     node_id = 'node_id'
     ctx = MockCloudifyContext(
         deployment_id='test',
         node_id=node_id,
         runtime_properties={
             'ip': '192.168.0.1'
         },
         properties={
             'cloudify_agent': {
                 'distro': 'Ubuntu',
             },
         },
         bootstrap_context=BootstrapContext({
             'cloudify_agent': {
                 'agent_key_path': KEY_FILE_PATH,
                 'user': getpass.getuser(),
             }
         })
     )
     conf = m(ctx)
     self.assertEqual(conf['port'], 22)
Beispiel #20
0
    def test_network_no_prefix(self, neutron_mock):
        ctx = self._setup_ctx('network')
        for pctx in common_test.BOOTSTRAP_CONTEXTS_WITHOUT_PREFIX:
            ctx._bootstrap_context = BootstrapContext(pctx)
            neutron_mock.create_network.reset_mock()
            neutron_mock.create_network.return_value = {
                'network': {
                    'id': 'network_id',
                    'name': 'network_name',
                }
            }

            with mock.patch('openstack_plugin_common._find_context_in_kw',
                            return_value=self.ctx):
                neutron_plugin.network.create(neutron_client=neutron_mock,
                                              ctx=self.ctx,
                                              args={})

            neutron_mock.create_network.assert_called_once_with(
                {'network': {
                    'name': 'network_name',
                    'admin_state_up': True
                }})
Beispiel #21
0
 def test_user_from_bootstrap_context(self):
     node_id = 'node_id'
     ctx = MockCloudifyContext(
         deployment_id='test',
         node_id=node_id,
         runtime_properties={
             'ip': '192.168.0.1'
         },
         properties={
             'cloudify_agent': {
                 'home_dir': self._get_home_dir(),
                 'distro': 'Ubuntu',
                 'distro_codename': 'trusty'
             },
         },
         bootstrap_context=BootstrapContext({
             'cloudify_agent': {
                 'agent_key_path': KEY_FILE_PATH,
                 'user': getpass.getuser()
             }
         })
     )
     conf = m(ctx)
     self.assertEqual(conf['user'], getpass.getuser())