def onAppInstalled(self, container):
data_transporter_service.fire(CONTAINER_CHANNEL, container)
try:
self.ui.install.setText(self._translate(self.template,
"Installed"))
except RuntimeError:
# When user close the add app dialog before app is installed
pass
def run(self):
self.events = docker_service.streamEvents()
for event in self.events:
channel = generate_key(event['Type'], event['Action'])
try:
data_transporter_service.fire(channel, event)
except Exception as e:
logger.error("exception occurred", e, exc_info=1)
logger.debug("Received an event: %s", event)
def run():
QApplication.setAttribute(Qt.AA_DisableHighDpiScaling)
QCoreApplication.setApplicationVersion(APP_VERSION)
QCoreApplication.setApplicationName("Boatswain")
app = QApplication(sys.argv)
system_service.resetStyle()
system_service.initialisingPath()
# Make sure app data dir always exists
if not os.path.isdir(APP_DATA_DIR):
os.makedirs(APP_DATA_DIR)
if not os.path.isdir(APP_AVATAR_DIR):
os.makedirs(APP_AVATAR_DIR)
# Connect to SQLite DB
db.connect(reuse_if_open=True)
db.create_tables(db_tables)
docker_service.setupClient()
system_service.reassignPemLocation()
logger.info("App data path: %s", APP_DATA_DIR)
# Load home window
window = Home()
# Close db before exit
data_transporter_service.listen(APP_EXIT_CHANNEL, lambda: db.close())
feed = Feed('theboatswain/boatswain')
pixmap = QIcon(getExternalResource('boatswain.svg')).pixmap(QSize(64, 64))
update_dialog = Updater(None, feed)
update_dialog.setIcon(pixmap)
update_dialog.installed.connect(onApplicationInstalled)
update_dialog.checkForUpdate(silent=True)
data_transporter_service.listen(UPDATES_CHANNEL,
update_dialog.checkForUpdate)
if docker_service.isDockerRunning():
window.show()
else:
# At this point, if the docker service is still not running, that mean, the Connection Management dialog
# has been closed or canceled. So, now, we just need to shut the application down.
# Prefetch default containers for search
data_transporter_service.fire(APP_EXIT_CHANNEL)
sys.exit(0)
containers_service.prefetchDefaultContainersInBackground()
# Stop daemon before exit
sys.exit(app.exec_())
def contextMenuEvent(self, event):
menu = QMenu(self.ui)
add_action = menu.addAction(self.tr('Add...'))
add_action.triggered.connect(
lambda: data_transporter_service.fire(ADD_APP_CHANNEL))
menu.addSeparator()
terminal = menu.addAction(self.tr('Connect to terminal'))
terminal.triggered.connect(
lambda: containers_service.connectToContainer(self.container))
monitor = menu.addAction(self.tr('Monitor log'))
monitor.triggered.connect(self.monitorLog)
menu.addSeparator()
conf = menu.addAction(self.tr('Configuration'))
conf.triggered.connect(
self.ui.advanced_app.onAdvancedConfigurationClicked)
pref_shortcut = menu.addAction(self.tr('Preferences shortcut'))
pref_shortcut.triggered.connect(self.onPreferenceShortcutClicked)
menu.addSeparator()
clone_to = QMenu(self.tr('Clone to...'), self.ui)
clone_to.addAction(self.tr('Unspecified workspace'))
for workspace in workspace_service.getWorkspaces():
clone_to.addAction(workspace.name)
clone_to.triggered.connect(self.cloneContainer)
menu.addMenu(clone_to)
menu.addSeparator()
restart = menu.addAction(self.tr('Restart'))
restart.triggered.connect(self.restartContainer)
reset = menu.addAction(self.tr('Reset'))
reset.triggered.connect(self.resetContainer)
delete = menu.addAction(self.tr('Delete'))
delete.triggered.connect(lambda: self.delete_app.emit(self.container))
menu.exec_(self.ui.mapToGlobal(event.pos()))
def contextMenuEvent(self, event):
menu = QMenu(self.ui)
add = menu.addAction(self.tr('Add app into this folder...'))
add.triggered.connect(
lambda: data_transporter_service.fire(ADD_APP_CHANNEL, self.group))
menu.addSeparator()
rename = menu.addAction(self.tr('Rename'))
rename.triggered.connect(self.onRenameTriggered)
delete = menu.addAction(self.tr('Delete'))
delete.triggered.connect(lambda: self.delete_group.emit(self.group))
menu.exec_(self.ui.mapToGlobal(event.pos()))
def cloneContainer(self, action):
clone_to_workspace = action.text()
if clone_to_workspace == 'Unspecified workspace':
workspace = workspace_service.getDefaultWorkspace()
else:
workspace = workspace_service.getWorkspace(clone_to_workspace)
worker = Worker(containers_service.cloneContainer, self.container,
workspace)
worker.signals.result.connect(
lambda x: data_transporter_service.fire(CONTAINER_CHANNEL, x))
threadpool.start(worker)
def onMenuClicked(self):
menu_help = QMenu(self.ui)
about = QAction(self.ui)
about.setMenuRole(QAction.AboutRole)
about.setText(self._translate("Boatswain", "About"))
about.triggered.connect(self.showAbout)
menu_help.addAction(about)
check_for_update = QAction(self.ui)
check_for_update.setText(
self._translate("Boatswain", "Check for updates"))
check_for_update.setMenuRole(QAction.ApplicationSpecificRole)
check_for_update.triggered.connect(
lambda: data_transporter_service.fire(UPDATES_CHANNEL, False))
menu_help.addAction(check_for_update)
menu_help.addSeparator()
preferences = QAction("Preferences…", self.ui)
menu_help.addAction(preferences)
point: QPoint = self.ui.mapToGlobal(self.ui.custom_menu.pos())
point.setY(point.y() + self.ui.custom_menu.height() + rt(5))
menu_help.exec_(point)
def closeEvent(self, event):
data_transporter_service.fire(APP_EXIT_CHANNEL)
QMainWindow.closeEvent(self, event)
def onApplicationInstalled():
# Once the application is updated, then relaunch it self
data_transporter_service.fire(APP_EXIT_CHANNEL)
logger.info('Relaunching %s' % sys.executable)
os.execlp(sys.executable, *sys.argv)
def fire(container: Container, name, value=None):
key = CONTAINER_CONF_CHANGED_CHANNEL + '_' + str(container.id) + '_' + name
data_transporter_service.fire(key, value)
