def onProfilesChanged():
app = runningApp()
for wpName, wp in app.webProfiles.items():
log.warning(f'Reconfiguring webprofile: {wpName}')
wp.configure()
def __init__(self,
name,
description='P2P description',
protocolName=None,
listenRange=None,
listenerClass=None,
handler=None,
enabled=True,
didDefaultRegister=False,
protocolVersion=None,
setupCtx=None,
**kwargs):
super().__init__(**kwargs)
self.app = runningApp()
self._name = name
self._description = description
self._protocolName = protocolName
self._protocolVersion = protocolVersion
self._listener = None
self._listenerClass = listenerClass
self._listenRange = listenRange if listenRange else \
('127.0.0.1', range(49400, 49500))
self._enabled = enabled
self._handler = handler
self._manager = None
self._setupCtx = setupCtx if setupCtx else {}
self._didDefaultRegister = didDefaultRegister
def __init__(self,
dataPath: Path = None,
runtimeConfig=None,
dotPath=None,
app=None,
config=None,
parent=None):
self.app = app if app else runningApp()
self.rtCfg = runtimeConfig
self.dotPath = dotPath
self._config = config
self.sServiceStarted = AsyncSignal()
if self.dotPath is None and parent and parent.dotPath:
self.dotPath = f'{parent.dotPath}.{self.name}'
if dataPath:
self.rootPath = dataPath
else:
self.rootPath = self.app.dataPathForService(
self.dotPath if self.dotPath else 'tmp')
Service.__init__(self)
KeyListener.__init__(self)
self.pubsubServices = []
self.serviceConfigBind()
def __init__(self, ethCtrl, name, pkgPath, offline=False, **kwargs):
planet = kwargs.pop('planet', 'earth')
initmod = kwargs.pop('initModule', None)
super(IPDapp, self).__init__()
self.app = runningApp()
self._ethController = ethCtrl
self._name = name
self._pkgPath = pkgPath
self._templatesPath = os.path.join(self._pkgPath, 'templates')
self._assetsPath = os.path.join(self._pkgPath, 'assets')
self._assetsCid = None
self._args = kwargs
self._planet = planet
self._offline = offline
self.cStore = {}
self._ctx_params = {}
self.jEnv = jinja2.Environment(loader=jinja2.FileSystemLoader(
self._templatesPath),
enable_async=True)
self.web3Channel = self.app.browserRuntime.web3Channel(self.name)
self._moduleInit = initmod
self._watcher = FileWatcher()
# self._watchT = QTimer()
# self._watchT.timeout.connect(
# lambda: self.pkgContentsChanged.emit(self.name))
self.watch(self._pkgPath)
self._watcher.pathChanged.connect(self.onFileWatchChange)
def __init__(self, parent=None):
super().__init__(parent)
self.app = runningApp()
self.ui = ui_dmessenger.Ui_MessengerForm()
self.ui.setupUi(self)
self.modelContacts = BMContactsModel(self)
self.messenger = Messenger(self.ui.mailBoxStack, self)
self.messageView = MessageViewer(self)
self.messageView.msgReplyStart.connect(self.onReplyToMessage)
self.messageView.msgComposeNewReq.connect(self.composeMessage)
self.messageComposer = MessageComposer(bmModel=self.modelContacts,
parent=self)
self.messageComposer.cancelled.connect(self.setDefaultView)
self.messageComposer.sendSuccess.connect(self.onSendSuccess)
self.sIdxView = self.ui.mailStack.addWidget(self.messageView)
self.sIdxCompose = self.ui.mailStack.addWidget(self.messageComposer)
self.ui.createMailboxButton.clicked.connect(
partialEnsure(self.onCreateMailbox))
self.ui.copyBmKeyButton.clicked.connect(partialEnsure(
self.onCopyBmKey))
self.ui.composeButton.clicked.connect(self.onComposeClicked)
self.ui.curMailboxCombo.currentIndexChanged.connect(
partialEnsure(self.onMailBoxSelect))
self.setDefaultView()
def __init__(self, fileUrl, parent=None):
super(QMLApplicationWidget, self).__init__(parent=parent)
self.setLayout(QVBoxLayout())
self.app = runningApp()
self.epFileUrl = fileUrl
self.fsw = FileWatcher(parent=self)
self.fsw.pathChanged.connect(self.onReloadApp)
self.fsw.watch(self.epFileUrl)
self.stack = QStackedWidget()
self.layout().addWidget(self.stack)
self.gInterface = GHandler(self)
self.iInterface = IHandler(self)
self.ldInterface = LDHandler(self)
self.sparqlInterface = SparQLHandler(self)
self.ipidInterface = IPIDHandler(self)
self.currentComponent = None
# Clone the IPFS profile
self.webProfile = self.app.webProfiles['ipfs'].quickClone()
# TODO: move this in global place
self.models = {
'Articles': ArticlesModel(),
'Channels': MultimediaChannelsModel(),
'Shouts': ShoutsModel()
}
self.setupEngine()
def __init__(self, torService, parent=None):
super().__init__(parent=parent, mode=QToolButton.InstantPopup)
self.app = runningApp()
self.tor = torService.proc
self.tor.torProto.sTorBootstrapStatus.connectTo(
self.onTorBootstrapStatus)
self.setObjectName('torControlButton')
self.setCheckable(True)
self.setChecked(False)
self.enableAction = QAction('Enable/disable Tor',
self,
triggered=self.onEnableDisable)
self.enableAction.setCheckable(True)
self.autoUseAction = QAction('Automatically use Tor as proxy',
self,
triggered=self.onAutoUse)
self.autoUseAction.setCheckable(True)
self.configApply()
self.menu.addAction(self.enableAction)
self.menu.addAction(self.autoUseAction)
configModRegCallback(self.onConfigChangedAsync,
mod=self.serviceConfigModule)
def __init__(self, sWidget, parent=None):
super().__init__(sWidget)
self.app = runningApp()
self.currentServiceItem = None
self.sWidget = sWidget
if 0:
self.sWidget.ui.vLayout.insertWidget(
0,
LabelWithURLOpener('<a href="manual:/pinning.html#remote">'
'Remote pinning manual'
'</a>'))
self.sWidget.ui.removeService.setEnabled(False)
self.sWidget.ui.rServiceConfigGroup.setEnabled(False)
self.sWidget.ui.rPinServiceAddButton.clicked.connect(
partialEnsure(self.onNewRemoteService))
self.sWidget.ui.removeService.clicked.connect(
partialEnsure(self.onRemoveService))
self.sWidget.ui.rPinServices.currentItemChanged.connect(
self.onCurrentServiceChanged)
self.iconSelector = IconSelector()
self.sWidget.ui.srvGridLayout.addWidget(self.iconSelector, 1, 1)
self.sWidget.ui.rpsPriority.valueChanged.connect(self.servicePatch)
self.iconSelector.iconSelected.connect(self.servicePatch)
def __init__(self, *args, **kwargs):
Handler.__init__(self, *args, **kwargs)
StringFormatterHandlerMixin.__init__(self, None)
self.app = runningApp()
self.loop = asyncio.get_event_loop()
self.ptask = self.loop.create_task(self._process())
self.__queue = asyncio.Queue()
def quickWidgetFromIpfs(ipfsPath: IPFSPath, parent=None):
app = runningApp()
url = app.subUrl(str(ipfsPath))
parentUrl = app.subUrl(str(ipfsPath.parent()))
qWidget = QQuickWidget(parent)
qWidget.engine().setBaseUrl(parentUrl)
qWidget.setSource(url)
return qWidget
def __init__(self, page=None, parent=None):
super(DWebView, self).__init__(parent)
self.app = runningApp()
self.channel = QWebChannel()
self.p = page
self.show()
self.webSettings = self.settings()
self.webSettings.setAttribute(QWebEngineSettings.LocalStorageEnabled,
True)
def __init__(self, parent=None, noMutexes=False):
super(BaseURLSchemeHandler, self).__init__(parent)
self.requests = {}
self.noMutexes = noMutexes
self.app = runningApp()
if self.psListenerClass:
# can't instantiate this before the hub is created ..
self.psListener = self.psListenerClass()
def __init__(self, dataPath: Path = None, runtimeConfig=None):
super().__init__()
self.app = runningApp()
self.rtCfg = runtimeConfig
if dataPath:
self.rootPath = dataPath
else:
self.rootPath = self.app.dataPathForService('tmp')
self.psKey = makeKeyService(self.name)
async def ldOps(self):
app = runningApp()
if not self._ldDocLoader:
self._ldDocLoader = await aioipfs_document_loader(
self.client,
app.ldSchemas
)
return LDOpsContext(
self,
self._ldDocLoader
)
def __init__(self, parent=None):
super().__init__(parent)
self.app = runningApp()
self.ui = ui_dmessenger_messageview.Ui_MessengerMailView()
self.ui.setupUi(self)
self.ui.replyButton.setEnabled(False)
self.ui.replyButton.clicked.connect(self.onReply)
self.browser.setOpenExternalLinks(False)
self.browser.setOpenLinks(False)
self.browser.anchorClicked.connect(
partialEnsure(self.onOpenMessageLink))
def onPinResult(self, f):
try:
path, code, msg = f.result()
except:
pass
else:
path = IPFSPath(path)
if not path.valid:
log.debug('Invalid path in pin result: {}'.format(str(path)))
return
if code == 0:
runningApp().systemTrayMessage('PIN',
iPinSuccess(str(path)),
timeout=2000)
elif code == 1:
runningApp().systemTrayMessage('PIN',
iPinError(str(path), msg),
timeout=3000)
elif code == 2:
# Cancelled, no need to notify here
pass
else:
log.debug('Unknown status code for pinning result')
def __init__(self, bmModel=None, parent=None):
super().__init__(parent)
self.app = runningApp()
self.completer = ComposeRecipientCompleter(self)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionColumn(1)
self.completer.setModel(bmModel)
self.ui = ui_dmessenger_compose.Ui_MessageComposerForm()
self.ui.setupUi(self)
self.ui.sendButton.clicked.connect(partialEnsure(self.onSend))
self.ui.cancelButton.clicked.connect(self.onCancelClicked)
self.ui.msgTo.setCompleter(self.completer)
self.ui.msgTo.textChanged.connect(self.onRecpChanged)
async def event_g_services(self, key, message):
from galacteek.dweb.channels.eth import EthSmartContractHandler
app = runningApp()
event = message['event']
if event['type'] == 'ContractLoadedEvent':
contract = event['contract']
cConfig = event['contractConfig']
webChannelName = cConfig.get('web3Channel', 'dpool')
chanObjName = cConfig.get('web3ChanObjName', 'NOPE')
channel = app.browserRuntime.web3Channel(
webChannelName)
handler = EthSmartContractHandler(contract['operator'],
parent=app)
handler.moveToThread(app.thread())
channel.register(chanObjName, handler)
async def remoteServicesScan(self, ipfsop):
"""
Scan remote pinning services and sync them to the config
"""
app = runningApp()
nodeId = await ipfsop.nodeId()
listing = await ipfsop.pinRemoteServiceList()
if not nodeId or not listing:
return
changed = False
for rService in listing:
if cfgpinning.rpsConfigRegister(rService, nodeId):
changed = True
if changed:
await app.s.ldPublish({'type': 'RPSConfigChanged'})
def __init__(self,
profile,
tmplMain,
ipfsConnParams,
searchMode='classic',
webchannel=None,
parent=None):
super(SearchResultsPage, self).__init__(parent, profile=profile)
self.app = runningApp()
self.channel = QWebChannel(self)
self.handler = IPFSSearchHandler(self)
self.channel.registerObject('ipfssearch', self.handler)
self.setWebChannel(self.channel)
self.setBackgroundColor(
QColor(self.app.theme.colors.webEngineBackground))
self.app = QApplication.instance()
self.searchMode = searchMode
self.template = tmplMain
self.ipfsConnParams = ipfsConnParams
ensure(self.render())
def hubPublish(key, message):
log.debug(f'hubPublish ({key}) : {message}')
# Hub publishing should now always happen in the main loop
app = runningApp()
app.loop.call_soon_threadsafe(gHub.publish, key, message)
async def queryAsync(self, query, initBindings=None):
def runQuery(q, bindings):
return self.query(q, initBindings=bindings)
return await self.loop.run_in_executor(runningApp().executor, runQuery,
query, initBindings)
def __init__(self, sWidget, parent=None):
super().__init__(sWidget)
self.app = runningApp()
self.sWidget = sWidget
def repolish(self):
runningApp().repolishWidget(self)
def __init__(self, ipService):
self.app = runningApp()
self.ipService = ipService
def onHelp(self):
runningApp().manuals.browseManualPage('pinning.html')
def __init__(self):
self.app = runningApp()
self.fsWatcher = FileWatcher()
self.fsWatcher.pathChanged.connect(self.onThemeChanged)
def __init__(self, service):
self.throttler = Throttler(rate_limit=30,
period=5.0,
retry_interval=2.0)
self.service = service
self.app = runningApp()
