rwth-acis / rest-ocd-services Goto Github PK

Adding UML diagrams can make documentation much more pleasant to read and better understandable.

Currently, Logging of the Service Class does not seem to write to any files, this should be fixed. Furthermore the requesthandler should not just log to console but also to files

Currently, the LFR benchmarks executables can fail to be run on linux systems that do not have some matching parts of the system they were built with. Therefore, implementing them in webOCD is needed to not require some users to build them themselves.

• LFR (based on lfr benchmark for weighted and directed graphs)
• Signed LFR (based on lfr benchmark for directed graphs)

Las2Peer provides swagger integration for services and methods are already (partially) annotated in the Service Class. This needs to be brought up to speed.
A working swagger ui would also be benefitial

When an algorithm is running the number of communities is displayed on the page of the cover which is really odd. The number of communities is set to the number of nodes in the graph. This makes the impression that the algorithm has finished and it puts all nodes in their own community. It might be better to show something like "in progress" or "running " instead of a number because technically no communities have been found yet.

Currently the Service doesn't seem to accept labeled membership matrix files (also those created with its own format) as a cover import.

The first problem is that it expects dots instead of commas for double values, while the other is yet unknown

With the addition of enforcing OCDA execution only on compatible graphs through #74 , a lot of OCDA become unusable for many graphs they were used for before (e.g. ones from LFR). It might be the case that for some of the algorithms, not all compatible graphs are set in the compatibleGraphTypes method of the algorithm. It can be a good idea to check this.

Currently, the tests for the Import from LMS triplestore are failing. This is likely to some recently made changes to the data that are not accounted for in WebOCD yet. The tests need to be adjusted

It can be useful to be able to access the algorithm parameters used to generate OCD covers.

Currently, the link to the integration tutorial of WebOCD on the front page of the site does not work. This needs to be corrected

With some ocd algorithms not being compatible for some graph types, we should disallow using them on incompatible ones per default.

Note: Execution on incompatible types could still be allowed but only if the user explicitly chooses to do so (e.g. tick a box in the web client).

DOCA Detecting Overlapping Communities Algorithm uses an executable. There is no corresponding Linux version.

Currently most algorithms print no output, some give basic info e.g. community count while some (e.g. Evolutionary Algorithm Based on Similarity) give too much info. It might be a good idea to standardize what the algorithm prints after execution. For example, the count of communities found.

Hi all,

I've bumped at this repository and found here really good examples of la4j API usage. Thanks for using it!

The library is almost ready for new release: 0.5.0. New version will include sparse iterators as well as efficient sparse operations (which is very useful for your case). I'm planing to release the 0.5.0 version in 3 weeks. If you want I can try to submit you a couple of pull-requests within the examples of new API so you can migrate the rest of the code by you own.

Anyway, I still planing to support the backward capability, so you can just update the library dependency and keep using the same API. This approach will work fine for the complex operations like matrix multiplications: you will get a huge performace gain here. But you still should rewrite your custom code (based on primitive matrix operations) with iteratos in order to increse the peformace there.

Please, let me know if you need any help with migrating the source code to new library version once it released.

The cooperation simulation component of WebOCD has been left unattended for long and sometimes uses own solutions instead of those provided by WebOCD itself, e.g. the ThreadHandler. We need to assess whether everything still works as intended in the Component and adjust it so that it works as the other components.

It's not an issue, it's just containing the images which will used in wiki page. As there is no way to upload images in the wiki, the image link of this issue would be used in the wiki.

The Webconnector of WebOCD should use a https certificate in the future at webocd.dbis.rwth-aachen.de to allow the site to also be used through https.

Some REST methods are still a bit sparingly annotated. Some may even be wrongly annotated. This needs to be brought up to speed

• Add new las2peer version 1.1.0 to dependencies, fix corresponding errors/deprecations
• Add compatibility to Java 14

Currently the ocd service itself is only really able to log wrong requests. It would be highly beneficial to relay more information regarding which algorithm is executed and with what parameters, adding to that if it fails and why it fails.
For algorithm classes we can for example currently not use the one of the service classes because using this logger outside the class does not produce any output. Using an own logger here would however produce an own file.
General ideas on how to circumvent this would be to either have one central object/class with a logger that gets information from other objects, or to use an other logging library than las2peers built in one

In order to use the newest las2peer version to 1.2.0 we need to match its Java version.

Currently we can only handle static networks, a way to handle dynamic networks would offer a range of new usage possibilities.

We need to have a webpage for easier access to wiki contents and better layout. Additional materials such as tutorials should also be present there

When a user, for example through the webclients graph table, fetches the overview of all graphs over the ocd/graphs endpoint, an overly large amount of memory seems to be accessed just for getting the necessary superficial information for these graphs.
Especially when a user builds a larger collection of graphs this can lead to longer loading times for the overview and in the worst case overwhelm the service.
Calling this endpoint therefore needs to consume much less graph memory

I think, we need a develop branch were we merge changes from feature branches. The develop branch can be used for running tests and planning releases.

Currently, changes made to a communitys color are not kept in the database, but needed for writing cover XMLs.
The colors therefore need to be persisted

We are currently still building with ant. Transition to the newer build environment of gradle with respect to the las2peer template project would be beneficial

Related to #12
Using HTTPS for communication currently stops responding to requests after a while. This needs to be fixed

Currently MEAs-SN still is a c program in a folder and therefore isn't directly a part of WebOCD. We need to have a Java implementation within WebOCD

Currently, algorithms excluded from further analysis with divideIntoConnectedComponents() in the OCDAlgorithmExecutor just have an execution time of 0 since the corresponding variable is only initalized but not filled afterwards. This needs to be fixed.

For someone who hasn't developed anything for WebOCD before, it might be time consuming to figure out how exactly new algorithms can be added. To make the experience more pleasant for the user, it makes sense to have a guide where the process is explained.

Until now, the user specified parameters of an algorithm are either int, double, or boolean. Adding support for enums makes it possible to change between different functions (weight-, ranking-, set-difference-functions, etc.) in the RunOCDAlgorithm form.

Currently, you cannot visually see how the community detecting algorithms on WebOCD are operating. The idea is to display short descriptive text on the corresponding nodes/edges while the algorithm is running, in order to better understand the procedure of the applied algorithm.

Currently, WebOCD does not really make use of the node features of las2peer. It would be ideal to have algorithms run on different nodes in order to make requests for the service less taxing

Gradle build of WebOCD fails on Linux. Building a docker image can also fail on Linux. The reason seems to be due to the path in persistence.xml <jar-file> tag.

Add a mechanism to limit object (graphs, covers etc.) sizes of specific users.

Since WebOCD is used for various lectures and seminars, in this context, it makes sense to be able to limit the users on graph element sizes (e.g. nodes/edges). This will prevent students who need WebOCD for some specific tasks from unnecessarily overloading it. These limits can be adjusted according to what the task of the seminar/lecture requires. These limits should be adjustable and specific to users/accounts.

A larger amount of older data seems to have piled up on our running instance. This marks one of the reasons why we need to have a means of deleting unused data. Ways can for example be:
-An administrator endpoint for deleting data of a specific user
-Deletion of content after a set amount of time.

Currently, the DOCA Algorithm still has no linux version and is not even used on windows systems because of that as well. Its junit test still fails. The linux variants executables of the lfr benchmarks and the signed probabilistic mixture algorithm are rather old and therefore do not work on some systems.

Currently, WebOCD does not build without precompilation(producing a tmp folder) in eclipse after get_deps. This needs to be fixed so that IntelliJ and command line can be used for builds as well.

Students working on a thesis related to WebOCD interact with different components such as the WebOCD service and web client. It can be useful to have a detailed tutorial on how to locally set these components up and deal with the possible problems, in order to aid with the thesis process.

y.jar dependencies should be replaced by open source implementations.

Currently the login through learning layers does not work, this is because the uri to be used has changed now. We need to adapt our URI accordingly.

computeTFIDF() in TermMatrix.java appears to not be working correctly. This affects the Combined Modularity metric and the content weighted algorithms.

Testcase: testDetectOverlappingCommunities
Caused an ERROR
Algorithm could not be executed.
java.io.IOException: java.util.InputMismatchException

Testcase: testGetMembershipMatrix
Caused an ERROR
java.util.InputMismatchException

On the graph page, the visualization stays blank for the following graph data:

0 1
1 0

Surprisingly, adding a node to it brings it back to life:

0 1
1 0
2 3