Radosgw main()

介绍

main()作为入口

分析

/  start up the RADOS connection and then handle HTTP messages as they come in /
  start up the RADOS connection and then handle HTTP messages as they come in
 /
int main(int argc, const char **argv){

 // dout() messages will be sent to stderr, but FCGX wants messages on stdout
 // Redirect stderr to stdout.
 TEMP_FAILURE_RETRY(close(STDERR_FILENO));
 if (TEMP_FAILURE_RETRY(dup2(STDOUT_FILENO, STDERR_FILENO) < 0)) {
 int err = errno;
 cout << “failed to redirect stderr to stdout: “ << cpp_strerror(err)
 << std::endl;
 return ENOSYS;
 }

 //设置默认参数
 / alternative default for module /
 vector<const char > def_args;
 def_args.push_back(“–debug-rgw=1/5”);
 def_args.push_back(“–keyring=$rgw_data/keyring”);
 def_args.push_back(“–log-file=/var/log/radosgw/$cluster-$name.log”);

 vector<const char> args;
 argv_to_vec(argc, argv, args); //循环将 argv 中的参数加到 args 中
 env_to_vec(args); //获取环境变量 CEPH_ARGS ，并加到 args 中
 global_init(&def_args, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
 CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS); // 创建目录/var/run/ceph 等初始化操作

 //判断 args 中是否有 -h 或 –help
 for (std::vector<const char>::iterator i = args.begin(); i != args.end(); ++i) {
 if (ceph_argparse_flag(args, i, “-h”, “–help”, (char)NULL)) {
 usage();
 return 0;
 }
 }

 check_curl(); //无操作

 if (g_conf->daemonize) {
 global_init_daemonize(g_ceph_context, 0);
 }
 Mutex mutex(“main”);
 SafeTimer init_timer(g_ceph_context, mutex);
 init_timer.init();
 mutex.Lock();
 init_timer.add_event_after(g_conf->rgw_init_timeout, new C_InitTimeout);
 mutex.Unlock();

 common_init_finish(g_ceph_context); //start service thread

 rgw_tools_init(g_ceph_context); //初始化mine map，读取文件/etc/mime.types

 rgw_init_resolver(); // new RGWResolver()
 rgw_rest_init(g_ceph_context); // 设置http header map、http code map

 curl_global_init(CURL_GLOBAL_ALL); // null
 
 FCGX_Init(); // null

 // 获得实例 store，获得实例meta_mgr、data_log，
 // init region、zone，初始化并启动 gc ，获得实例 qutoa_hander
 int r = 0;
 RGWRados store = RGWStoreManager::get_storage(g_ceph_context, true, true);
 if (!store) {
 derr << “Couldn’t init storage provider (RADOS)” << dendl;
 r = EIO;
 }
 if (!r)
 r = rgw_perf_start(g_ceph_context);

 mutex.Lock();
 init_timer.cancel_all_events();
 init_timer.shutdown();
 mutex.Unlock();

 if (r) 
 return 1;

 rgw_user_init(store->meta_mgr); // 注册 user_meta_handler
 rgw_bucket_init(store->meta_mgr); //注册 bucket_meta_handler、bucket_instance_meta_handler
 rgw_log_usage_init(g_ceph_context, store);

 RGWREST rest;

 list<string> apis;
 bool do_swift = false;

 get_str_list(g_conf->rgw_enable_apis, apis); // 获得apis，默认 s3, swift, swift_auth, admin

 map<string, bool> apis_map;
 for (list<string>::iterator li = apis.begin(); li != apis.end(); ++li) {
 apis_map[li] = true;
 }

 if (apis_map.count(“s3”) > 0)
 rest.register_default_mgr(set_logging(new RGWRESTMgr_S3));

 if (apis_map.count(“swift”) > 0) {
 do_swift = true;
 swift_init(g_ceph_context);
 rest.register_resource(g_conf->rgw_swift_url_prefix, set_logging(new RGWRESTMgr_SWIFT));
 }

 if (apis_map.count(“swift_auth”) > 0)
 rest.register_resource(g_conf->rgw_swift_auth_entry, set_logging(new RGWRESTMgr_SWIFT_Auth));

 if (apis_map.count(“admin”) > 0) {
 RGWRESTMgr_Admin admin_resource = new RGWRESTMgr_Admin;
 admin_resource->register_resource(“usage”, new RGWRESTMgr_Usage);
 admin_resource->register_resource(“user”, new RGWRESTMgr_User);
 admin_resource->register_resource(“bucket”, new RGWRESTMgr_Bucket);
 
 /Registering resource for /admin/metadata /
 admin_resource->register_resource(“metadata”, new RGWRESTMgr_Metadata);
 admin_resource->register_resource(“log”, new RGWRESTMgr_Log);
 admin_resource->register_resource(“opstate”, new RGWRESTMgr_Opstate);
 admin_resource->register_resource(“replica_log”, new RGWRESTMgr_ReplicaLog);
 admin_resource->register_resource(“config”, new RGWRESTMgr_Config);
 rest.register_resource(g_conf->rgw_admin_entry, admin_resource);
 }

 //日志文件
 OpsLogSocket olog = NULL;

 if (!g_conf->rgw_ops_log_socket_path.empty()) {
 olog = new OpsLogSocket(g_ceph_context, g_conf->rgw_ops_log_data_backlog);
 olog->init(g_conf->rgw_ops_log_socket_path);
 }

 r = signal_fd_init();
 if (r < 0) {
 derr << “ERROR: unable to initialize signal fds” << dendl;
 exit(1);
 }

 init_async_signal_handler();
 register_async_signal_handler(SIGHUP, sighup_handler);
 register_async_signal_handler(SIGTERM, handle_sigterm);
 register_async_signal_handler(SIGINT, handle_sigterm);
 register_async_signal_handler(SIGUSR1, handle_sigterm);
 sighandler_alrm = signal(SIGALRM, godown_alarm);

 string frontend_frameworks = g_conf->rgw_frontends;

 list<string> frontends;

 get_str_list(g_conf->rgw_frontends, “,”, frontends);

 multimap<string, RGWFrontendConfig > fe_map;
 list<RGWFrontendConfig > configs;
 if (frontends.empty()) {
 frontends.push_back(“fastcgi”);
 }
 for (list<string>::iterator iter = frontends.begin(); iter != frontends.end(); ++iter) {
 string& f = iter;

 RGWFrontendConfig config = new RGWFrontendConfig(f);
 int r = config->init();
 if (r < 0) {
 cerr << “ERROR: failed to init config: “ << f << std::endl;
 return EINVAL;
 }

 configs.push_back(config);

 string framework = config->get_framework();
 fe_map.insert(make_pair<string, RGWFrontendConfig >(framework, config));
 }

 list<RGWFrontend > fes;

 for (multimap<string, RGWFrontendConfig >::iterator fiter = fe_map.begin(); fiter != fe_map.end(); ++fiter) {
 RGWFrontendConfig config = fiter->second;
 string framework = config->get_framework();
 RGWFrontend fe;
 if (framework == “fastcgi” || framework == “fcgi”) {
 RGWProcessEnv fcgi_pe = { store, &rest, olog, 0 };

 fe = new RGWFCGXFrontend(fcgi_pe, config);
 } else if (framework == “civetweb” || framework == “mongoose”) {
 string err;

 int port;
 config->get_val(“port”, 80, &port);

 RGWProcessEnv env = { store, &rest, olog, port };

 fe = new RGWMongooseFrontend(env, config);
 } else if (framework == “loadgen”) {
 int port;
 config->get_val(“port”, 80, &port);

 RGWProcessEnv env = { store, &rest, olog, port };

 fe = new RGWLoadGenFrontend(env, config);
 } else {
 dout(0) << “WARNING: skipping unknown framework: “ << framework << dendl;
 continue;
 }
 dout(0) << “starting handler: “ << fiter->first << dendl;
 int r = fe->init();
 if (r < 0) {
 derr << “ERROR: failed initializing frontend” << dendl;
 return -r;
 }
 fe->run();

 fes.push_back(fe);
 }

 wait_shutdown();

 derr << “shutting down” << dendl;

 for (list<RGWFrontend >::iterator liter = fes.begin(); liter != fes.end(); ++liter) {
 RGWFrontend fe = liter;
 fe->stop();
 }

 for (list<RGWFrontend >::iterator liter = fes.begin(); liter != fes.end(); ++liter) {
 RGWFrontend fe = liter;
 fe->join();
 delete fe;
 }

 for (list<RGWFrontendConfig >::iterator liter = configs.begin(); liter != configs.end(); ++liter) {
 RGWFrontendConfig fec = *liter;
 delete fec;
 }

 unregister_async_signal_handler(SIGHUP, sighup_handler);
 unregister_async_signal_handler(SIGTERM, handle_sigterm);
 unregister_async_signal_handler(SIGINT, handle_sigterm);
 unregister_async_signal_handler(SIGUSR1, handle_sigterm);
 shutdown_async_signal_handler();

 if (do_swift) {
 swift_finalize();
 }

 rgw_log_usage_finalize();

 delete olog;

 rgw_perf_stop(g_ceph_context);

 RGWStoreManager::close_storage(store);

 rgw_tools_cleanup();
 rgw_shutdown_resolver();
 curl_global_cleanup();

 dout(1) << “final shutdown” << dendl;
 g_ceph_context->put();

 ceph::crypto::shutdown();

 signal_fd_finalize();

 return 0;
}