IConnectionSettingsBaseSPtr IClusterSettingsBase::findSettingsByHost(const common::net::hostAndPort& host) const { for(int i = 0; i < clusters_nodes_.size(); ++i){ IConnectionSettingsBaseSPtr cur = clusters_nodes_[i]; if(cur->host() == host){ return cur; } } return IConnectionSettingsBaseSPtr(); }
void SettingsManager::save() { QSettings settings(common::convertFromString<QString>(common::file_system::prepare_path(iniPath)), QSettings::IniFormat); DCHECK(settings.status() == QSettings::NoError); settings.setValue(STYLE, curStyle_); settings.setValue(FONT, curFontName_); settings.setValue(LANGUAGE, curLanguage_); settings.setValue(VIEW, views_); QList<QVariant> clusters; for(ClusterSettingsContainerType::const_iterator it = clusters_.begin(); it != clusters_.end(); ++it){ IClusterSettingsBaseSPtr conn = *it; if(conn){ std::string raw = conn->toString(); std::string enc = common::utils::base64::encode64(raw); QString qdata = common::convertFromString<QString>(enc); clusters.push_back(qdata); } } settings.setValue(CLUSTERS, clusters); QList<QVariant> connections; for(ConnectionSettingsContainerType::const_iterator it = connections_.begin(); it != connections_.end(); ++it){ IConnectionSettingsBaseSPtr conn = *it; if(conn){ std::string raw = conn->toString(); std::string enc = common::utils::base64::encode64(raw); QString qdata = common::convertFromString<QString>(enc); connections.push_back(qdata); } } settings.setValue(CONNECTIONS, connections); QStringList rconnections; for(QStringList::const_iterator it = recentConnections_.begin(); it != recentConnections_.end(); ++it){ QString conn = *it; if(!conn.isEmpty()){ std::string raw = common::convertToString(conn); std::string enc = common::utils::base64::encode64(raw); QString qdata = common::convertFromString<QString>(enc); rconnections.push_back(qdata); } } settings.setValue(RCONNECTIONS, rconnections); settings.setValue(SYNCTABS, syncTabs_); settings.setValue(LOGGINGDIR, loggingDir_); settings.setValue(CHECKUPDATES, autoCheckUpdate_); settings.setValue(AUTOCOMPLETION, autoCompletion_); settings.setValue(AUTOOPENCONSOLE, autoOpenConsole_); settings.setValue(FASTVIEWKEYS, fastViewKeys_); }
std::string IClusterSettingsBase::toString() const { DCHECK(type_ != DBUNKNOWN); std::stringstream str; str << IConnectionSettings::toString() << ','; for(int i = 0; i < clusters_nodes_.size(); ++i){ IConnectionSettingsBaseSPtr serv = clusters_nodes_[i]; if(serv){ str << magicNumber << serv->toString(); } } std::string res = str.str(); return res; }
IServerSPtr ServersManager::createServer(IConnectionSettingsBaseSPtr settings) { DCHECK(settings); IServerSPtr result; connectionTypes conT = settings->connectionType(); IServerSPtr ser = findServerBySetting(settings); if(conT == REDIS){ RedisServer *newRed = NULL; if(!ser){ IDriverSPtr dr(new RedisDriver(settings)); dr->start(); newRed = new RedisServer(dr, true); } else{ newRed = new RedisServer(ser->driver(), false); } result.reset(newRed); servers_.push_back(result); } else if(conT == MEMCACHED){ MemcachedServer *newMem = NULL; if(!ser){ IDriverSPtr dr(new MemcachedDriver(settings)); dr->start(); newMem = new MemcachedServer(dr, true); } else{ newMem = new MemcachedServer(ser->driver(), false); } result.reset(newMem); servers_.push_back(result); } else if(conT == SSDB){ SsdbServer *newSsdb = NULL; if(!ser){ IDriverSPtr dr(new SsdbDriver(settings)); dr->start(); newSsdb = new SsdbServer(dr, true); } else{ newSsdb = new SsdbServer(ser->driver(), false); } result.reset(newSsdb); servers_.push_back(result); } DCHECK(result); if(ser && syncServers_){ result->syncWithServer(ser.get()); } return result; }
void ConnectionsDialog::edit() { QTreeWidgetItem* qitem = listWidget_->currentItem(); if(!qitem){ return; } ConnectionListWidgetItem* currentItem = dynamic_cast<ConnectionListWidgetItem *>(qitem); if(currentItem){ QTreeWidgetItem* qpitem = qitem->parent(); if(!qpitem){ IConnectionSettingsBaseSPtr con = currentItem->connection(); ConnectionDialog dlg(this, dynamic_cast<IConnectionSettingsBase*>(con->clone())); int result = dlg.exec(); IConnectionSettingsBaseSPtr newConnection = dlg.connection(); if(result == QDialog::Accepted && newConnection){ currentItem->setConnection(newConnection); SettingsManager::instance().removeConnection(con); SettingsManager::instance().addConnection(newConnection); } return; } else{ qitem = qpitem; } } ClusterConnectionListWidgetItem* clCurrentItem = dynamic_cast<ClusterConnectionListWidgetItem *>(qitem); if(clCurrentItem){ IClusterSettingsBaseSPtr con = clCurrentItem->connection(); ClusterDialog dlg(this, dynamic_cast<IClusterSettingsBase*>(con->clone())); int result = dlg.exec(); IClusterSettingsBaseSPtr newConnection = dlg.connection(); if(result == QDialog::Accepted && newConnection){ clCurrentItem->setConnection(newConnection); SettingsManager::instance().removeCluster(con); SettingsManager::instance().addCluster(newConnection); } } }
IServerSPtr ServersManager::createServer(IConnectionSettingsBaseSPtr settings) { if (!settings) { NOTREACHED(); return IServerSPtr(); } connectionTypes conT = settings->type(); IServer* server = nullptr; #ifdef BUILD_WITH_REDIS if (conT == REDIS) { server = new redis::RedisServer(settings); } #endif #ifdef BUILD_WITH_MEMCACHED if (conT == MEMCACHED) { server = new memcached::MemcachedServer(settings); } #endif #ifdef BUILD_WITH_SSDB if (conT == SSDB) { server = new ssdb::SsdbServer(settings); } #endif #ifdef BUILD_WITH_LEVELDB if (conT == LEVELDB) { server = new leveldb::LeveldbServer(settings); } #endif #ifdef BUILD_WITH_ROCKSDB if (conT == ROCKSDB) { server = new rocksdb::RocksdbServer(settings); } #endif #ifdef BUILD_WITH_UNQLITE if (conT == UNQLITE) { server = new unqlite::UnqliteServer(settings); } #endif #ifdef BUILD_WITH_LMDB if (conT == LMDB) { server = new lmdb::LmdbServer(settings); } #endif if (!server) { NOTREACHED(); return IServerSPtr(); } IServerSPtr sh(server); servers_.push_back(sh); return sh; }
common::Error ServersManager::discoveryConnection(IConnectionSettingsBaseSPtr connection, std::vector<ServerDiscoveryInfoSPtr>* inf) { if (!connection || !inf) { return common::make_error_value("Invalid input argument", common::ErrorValue::E_ERROR); } connectionTypes type = connection->type(); #ifdef BUILD_WITH_REDIS if (type == REDIS) { return fastonosql::redis::discoveryConnection(dynamic_cast<redis::RedisConnectionSettings*>(connection.get()), inf); } #endif #ifdef BUILD_WITH_MEMCACHED if (type == MEMCACHED) { return common::make_error_value("Not supported setting type", common::ErrorValue::E_ERROR); } #endif #ifdef BUILD_WITH_SSDB if (type == SSDB) { return common::make_error_value("Not supported setting type", common::ErrorValue::E_ERROR); } #endif #ifdef BUILD_WITH_LEVELDB if (type == LEVELDB) { return common::make_error_value("Not supported setting type", common::ErrorValue::E_ERROR); } #endif #ifdef BUILD_WITH_ROCKSDB if (type == ROCKSDB) { return common::make_error_value("Not supported setting type", common::ErrorValue::E_ERROR); } #endif #ifdef BUILD_WITH_UNQLITE if (type == UNQLITE) { return common::make_error_value("Not supported setting type", common::ErrorValue::E_ERROR); } #endif #ifdef BUILD_WITH_LMDB if (type == LMDB) { return common::make_error_value("Not supported setting type", common::ErrorValue::E_ERROR); } #endif return common::make_error_value("Invalid setting type", common::ErrorValue::E_ERROR); }
common::Error ServersManager::testConnection(IConnectionSettingsBaseSPtr connection) { if (!connection) { NOTREACHED(); return common::make_error_value("Invalid input argument", common::ErrorValue::E_ERROR); } connectionTypes type = connection->type(); #ifdef BUILD_WITH_REDIS if (type == REDIS) { return fastonosql::redis::testConnection(dynamic_cast<redis::RedisConnectionSettings*>(connection.get())); } #endif #ifdef BUILD_WITH_MEMCACHED if (type == MEMCACHED) { return fastonosql::memcached::testConnection(dynamic_cast<memcached::MemcachedConnectionSettings*>(connection.get())); } #endif #ifdef BUILD_WITH_SSDB if (type == SSDB) { return fastonosql::ssdb::testConnection(dynamic_cast<ssdb::SsdbConnectionSettings*>(connection.get())); } #endif #ifdef BUILD_WITH_LEVELDB if (type == LEVELDB) { return fastonosql::leveldb::testConnection(dynamic_cast<leveldb::LeveldbConnectionSettings*>(connection.get())); } #endif #ifdef BUILD_WITH_ROCKSDB if (type == ROCKSDB) { return fastonosql::rocksdb::testConnection(dynamic_cast<rocksdb::RocksdbConnectionSettings*>(connection.get())); } #endif #ifdef BUILD_WITH_UNQLITE if (type == UNQLITE) { return fastonosql::unqlite::testConnection(dynamic_cast<unqlite::UnqliteConnectionSettings*>(connection.get())); } #endif #ifdef BUILD_WITH_LMDB if (type == LMDB) { return fastonosql::lmdb::testConnection(dynamic_cast<lmdb::LmdbConnectionSettings*>(connection.get())); } #endif return common::make_error_value("Invalid setting type", common::ErrorValue::E_ERROR); }
IServerSPtr ServersManager::createServer(IConnectionSettingsBaseSPtr settings) { DCHECK(settings); IServerSPtr result; connectionTypes conT = settings->connectionType(); IServerSPtr ser = findServerBySetting(settings); #ifdef BUILD_WITH_REDIS if(conT == REDIS){ result.reset(make_server<RedisServer, RedisDriver>(ser, settings)); } #endif #ifdef BUILD_WITH_MEMCACHED if(conT == MEMCACHED){ result.reset(make_server<MemcachedServer, MemcachedDriver>(ser, settings)); } #endif #ifdef BUILD_WITH_SSDB if(conT == SSDB){ result.reset(make_server<SsdbServer, SsdbDriver>(ser, settings)); } #endif #ifdef BUILD_WITH_LEVELDB if(conT == LEVELDB){ result.reset(make_server<LeveldbServer, LeveldbDriver>(ser, settings)); } #endif DCHECK(result); if(result){ servers_.push_back(result); if(ser && syncServers_){ result->syncWithServer(ser.get()); } } return result; }
ConnectionDiagnosticDialog::ConnectionDiagnosticDialog(QWidget* parent, IConnectionSettingsBaseSPtr connection) : QDialog(parent) { using namespace translations; setWindowTitle(trConnectionDiagnostic); setWindowIcon(GuiFactory::instance().icon(connection->connectionType())); setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint); // Remove help button (?) QVBoxLayout* mainLayout = new QVBoxLayout; executeTimeLabel_ = new QLabel; executeTimeLabel_->setText(connectionStatusTemplate.arg("execute...")); mainLayout->addWidget(executeTimeLabel_); statusLabel_ = new QLabel(timeTemplate.arg("calculate...")); iconLabel_ = new QLabel; QIcon icon = GuiFactory::instance().failIcon(); const QPixmap pm = icon.pixmap(stateIconSize); iconLabel_->setPixmap(pm); mainLayout->addWidget(statusLabel_); mainLayout->addWidget(iconLabel_, 1, Qt::AlignCenter); QDialogButtonBox* buttonBox = new QDialogButtonBox; buttonBox->setOrientation(Qt::Horizontal); buttonBox->setStandardButtons(QDialogButtonBox::Ok); VERIFY(connect(buttonBox, &QDialogButtonBox::accepted, this, &ConnectionDiagnosticDialog::accept)); mainLayout->addWidget(buttonBox); setFixedSize(QSize(fix_width, fix_height)); setLayout(mainLayout); glassWidget_ = new fasto::qt::gui::GlassWidget(GuiFactory::instance().pathToLoadingGif(), trTryToConnect, 0.5, QColor(111, 111, 100), this); testConnection(connection); }