def test_init_exists(self):
        with mock.patch('os.path.isdir') as isdir:
            with mock.patch('os.unlink') as unlink:
                isdir.return_value = True
                agent.UnixDomainMetadataProxy(mock.Mock())

                isdir.assert_called_once_with('/the')
                unlink.assert_called_once_with('/the/path')
Exemple #2
0
 def test_init_state_reporting(self):
     with mock.patch('neutron.openstack.common.loopingcall.'
                     'FixedIntervalLoopingCall') as loop_call:
         with mock.patch('os.makedirs'):
             proxy = agent.UnixDomainMetadataProxy(mock.Mock())
             loop_call.assert_called_once_with(proxy._report_state)
             loop_call.return_value.start.assert_called_once_with(
                 interval=mock.ANY)
    def test_init_doesnot_exists(self):
        with mock.patch('os.path.isdir') as isdir:
            with mock.patch('os.makedirs') as makedirs:
                isdir.return_value = False
                agent.UnixDomainMetadataProxy(mock.Mock())

                isdir.assert_called_once_with('/the')
                makedirs.assert_called_once_with('/the', 0o755)
    def test_init_exists_unlink_no_file(self):
        with mock.patch('os.path.isdir') as isdir:
            with mock.patch('os.unlink') as unlink:
                with mock.patch('os.path.exists') as exists:
                    isdir.return_value = True
                    exists.return_value = False
                    unlink.side_effect = OSError

                    agent.UnixDomainMetadataProxy(mock.Mock())
                    unlink.assert_called_once_with('/the/path')
Exemple #5
0
 def test_report_state(self):
     with mock.patch('neutron.agent.rpc.PluginReportStateAPI') as state_api:
         with mock.patch('os.makedirs'):
             proxy = agent.UnixDomainMetadataProxy(mock.Mock())
             self.assertTrue(proxy.agent_state['start_flag'])
             proxy._report_state()
             self.assertNotIn('start_flag', proxy.agent_state)
             state_api_inst = state_api.return_value
             state_api_inst.report_state.assert_called_once_with(
                 proxy.context, proxy.agent_state, use_call=True)
    def test_init_exists_unlink_fails_file_still_exists(self):
        with mock.patch('os.path.isdir') as isdir:
            with mock.patch('os.unlink') as unlink:
                with mock.patch('os.path.exists') as exists:
                    isdir.return_value = True
                    exists.return_value = True
                    unlink.side_effect = OSError

                    with testtools.ExpectedException(OSError):
                        agent.UnixDomainMetadataProxy(mock.Mock())
                    unlink.assert_called_once_with('/the/path')
def main():
    cfg.CONF.register_opts(metadata_conf.UNIX_DOMAIN_METADATA_PROXY_OPTS)
    cfg.CONF.register_opts(metadata_conf.METADATA_PROXY_HANDLER_OPTS)
    cache.register_oslo_configs(cfg.CONF)
    cfg.CONF.set_default(name='cache_url', default='memory://?default_ttl=5')
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    config.init(sys.argv[1:])
    config.setup_logging()
    utils.log_opt_values(LOG)
    proxy = agent.UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()
def main():
    meta.register_meta_conf_opts(meta.SHARED_OPTS)
    meta.register_meta_conf_opts(meta.UNIX_DOMAIN_METADATA_PROXY_OPTS)
    meta.register_meta_conf_opts(meta.METADATA_PROXY_HANDLER_OPTS)
    cache.register_oslo_configs(cfg.CONF)
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    config.init(sys.argv[1:])
    config.setup_logging()
    utils.log_opt_values(LOG)
    proxy = agent.UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()
Exemple #9
0
    def test_run(self, ensure_dir, server, handler):
        p = agent.UnixDomainMetadataProxy(self.cfg.CONF)
        p.run()

        ensure_dir.assert_called_once_with('/the')
        server.assert_has_calls([
            mock.call('neutron-metadata-agent'),
            mock.call().start(handler.return_value,
                              '/the/path', workers=0,
                              backlog=128, mode=0o644),
            mock.call().wait()]
        )
    def test_run(self, ensure_dir, server, handler):
        p = agent.UnixDomainMetadataProxy(self.cfg.CONF)
        p.run()

        ensure_dir.assert_called_once_with('/the', mode=0o755)
        server.assert_has_calls([
            mock.call(n_const.AGENT_PROCESS_METADATA),
            mock.call().start(handler.return_value,
                              '/the/path', workers=0,
                              backlog=128, mode=0o644),
            mock.call().wait()]
        )
        self.looping_mock.assert_called_once_with(p._report_state)
        self.looping_mock.return_value.start.assert_called_once_with(
            interval=mock.ANY)
Exemple #11
0
    def test_run(self):
        with mock.patch.object(agent, 'MetadataProxyHandler') as handler:
            with mock.patch.object(agent, 'UnixDomainWSGIServer') as server:
                with mock.patch('os.path.isdir') as isdir:
                    with mock.patch('os.makedirs') as makedirs:
                        isdir.return_value = False

                        p = agent.UnixDomainMetadataProxy(self.cfg.CONF)
                        p.run()

                        isdir.assert_called_once_with('/the')
                        makedirs.assert_called_once_with('/the', 0o755)
                        server.assert_has_calls([
                            mock.call('neutron-metadata-agent'),
                            mock.call().start(handler.return_value,
                                              '/the/path'),
                            mock.call().wait()
                        ])
 def test_init_doesnot_exists(self, ensure_dir):
     agent.UnixDomainMetadataProxy(mock.Mock())
     ensure_dir.assert_called_once_with('/the')
Exemple #13
0
 def test_init_state_reporting(self):
     with mock.patch('os.makedirs'):
         proxy = agent.UnixDomainMetadataProxy(mock.Mock())
         self.looping_mock.assert_called_once_with(proxy._report_state)
         self.looping_mock.return_value.start.assert_called_once_with(
             interval=mock.ANY)