Automated Rule-Based Selection and Instantiation of Layout Templates for Widget-Based Microsites

Veebi avatud arhitektuuron loonud soodsa pinnase veebisolevate andmete kasutamiseks nii keerulisemates kui lihtsamates veebirakendustes. Andmete kogumise ja visualiseerimise lihtsustamiseks lihtsates veebirakendustes on loodud hulganisti tööriistu, mille seas on ka mashup'ide loomise tööriistad. Olemasolevate tööriistadega kõrge kasutatavusega mashup veebilehe loomine võib aga paraku olla keerukas, kuna nõuab erinevate tehnoloogiate ning programmeerimiskeelte tundmist, rääkimata kasutatavuse juhtnööridega kursisolemist. Kuigi osad mashup'ide platvormid, a'la OpenAjax Hub, lihtsustavad olemasolevate komponentide kombineerimist, on lahendamata probleemiks siiani nende rakenduste kasutatavus. Käesolev magistritöö kirjeldab reeglipõhist lahendust andmete visualiseerimise vidinate jaoks sobiva veebilehe malli automaatseks valimiseks vastavalt enimlevinud veebilehtede kasutatavuse juhtnööridele. Selleks laetakse vidinate ning struktuurimallide kirjeldused koos kasutatavuse juhtnööridest saadud reeglitega reeglimootorisse ning kasutatakse reeglimootorit ekspertsüsteemina, mis soovitab sobivamaid malle vastavalt etteantud vidinate komplektile. Lahenduse reeglipõhine ülesehitus võimaldab uute vidinate ning mallide lisandumisel või juhtnööride muutumisel operatiivselt reageerida nendele muutustele reeglibaasi täiendamise kaudu. Väljapakutud lahendus realiseeriti käesoleva töö raames Auto Microsite rakendusena, mis koosneb serveri- ning kliendipoolsest osast. Serveri poolel toimub reeglite abil vidinate komplekti visualiseerimiseks sobiva malli valimine kasutades OO jDREW RuleML reeglimootorit ning rakenduse paketeerimiseks koodi genereerimine. Kliendi poolel kasutatakse OpenAjax Hub raamistikkuvidinate turvaliseks eraldamiseks ning omavahel suhtlemapanemisel. Samuti on kliendi poolel lahendatud genereeritud veebilehe vastavusse viimine brauseri võimalustega. Katsetamaks Auto Microsite rakendust praktikas loodi seda kasutades realisatsioonid kahele lihtsale stsenaariumile. Esimesel juhul viusaliseeriti Euroopa 1997-2008 tööjõukulude (Hourly labour costs in Euros (European Union 1997-2008) ing. k.) andmeid kaardi, tabeli, kokkuvõtte ja menüü vidinatega. Teisel juhul kasutati lisaks andmete visualiseerimise vidinatele ka väliseid andmeallikaid, mis olid realiseeritud mittevisuaalsete vidinatena. Saadud andmed visualiseeriti kahe tabeli ning ühe kaardi vidinaga. Näidisveebilehtede loomise tulemusena järeldub, et rakendus sobib lihtsate veebilehtede loomiseks. Lisaks on võimalik lahendust täiendada keerukamate veebirakenduste automaatseks loomiseks läbi vastavate mallide ning reeglite lisamise.This thesis proposes a rule-based widget and layout template matchmaking solution for widget-based microsites. The solution takes as an input a set of widget descriptions and a set of layout templates with widget placeholders and returns a microsite, where the most suitable template has been instantiated with corresponding widgets. Matchmaking is based on applying a rule engine to metadata of widgets and placeholders about their content categories and dimensions,. Additional usability rules are used to further improve the results with respect to commonly accepted usability guidelines. Such a solution makes it possible to modularly enhance the usability results in the future simply by adding new usability rules and layout templates. Furthermore, the solution can be applied in mashup creation tools for layout selection. The proposed solution has been implemented and is called Auto Microsite in this thesis. The system consists of a server-side and a client-side component. The server-side component matches widgets with layout template placeholders according to the given rules by using the OO jDREW RuleML engine. The client-side is responsible for presenting the mashup appropriately for the client device. The latter is based on OpenAjax Hub 2.0 framework, which enables secure sandboxing and communication of widgets in the generated microsite. Furthermore, OpenAjax Metadata 1.0 specification is used in this thesis to package the widgets such that they could be easily reused. In order to evaluate the Auto Microsite system in practice two proof of concept (PoC) scenarios were implemented. The first scenario visualized "Hourly labour costs in Euros (European Union 1997-2008)" data using widgets for a map, a table and a summary. In the second scenario, also data was queried through a SOAP service and a Web site. In the scenario data was visualized using two table widgets and a map widget. The SOAP service and queries to the Web site were packaged as non-visual widgets to fit the framework. The POCs demonstrate that the Auto Microsite system is able to construct widget-based microsites. Furthermore, the framework is capable of constructing also more complex Web applications, with several pages and more content widgets, by adding new rules and templates

Automated OpenAjax Hub Widget Generation for Deep Web Surfacing

Antud magistritöö uurib, kuidas lihtsustada esitluskihil SOAP protokolli kasutavate veebiteenuste, mis on osa süvaveebist, kasutamist. Sellise teema valimist motiveerib asjaolu, et rakenduste kompositsiooniline raskuskese liigub üha enam esitluskihi suunas, kuid hetkel ei ole veebilehitsejale omaste tehnoloogiatega võimalik väliste domeenide teenuseid kasutada, nende väljundit kuvada ja teenuseid omavahel siduda. Et välja selgitada, kuidas antud probleemi lahendada, uuriti, mis on hetkel sellise lähenemise kasutusse võtmisel peamised pidurdavad tegurid. Selgus, et põhilisi raskusi tekitavad asjaolud, et veebilehitsejad ei võimalda teha päringuid rakenduse suhtes välistesse domeenidesse ja et JavaScriptis on SOAP päringute koostamise tugi võrdlemisi limiteeritud. Lisaks tõdeti, et teenustest saadava info visualiseerimine nõuab teenuse väljundi ja kuvamisloogika manuaalset kokku-traageldamist (hard-wiring ing k). Probleemi lahendamiseks otsustati kasutada nö veebividinapõhist lähenemist, kus iga teenuse operatsiooni jaoks genereeritakse nähtamatu JavaScripti vidin, millelt saadav info muudetakse nähtavaks mõne teise vidina poolt. Sellise lähenemise rakendamiseks loodi kaheosaline raamistik, mis koosneb kliendikihist ja serverikihist. Vidinate suhtlemise võimaldamiseks võeti kasutusele OpenAjax Hub raamistik, mis toimib vidinatevaheliste sõnumite vahendajana. Selleks, et vidinad ei oleks tihedalt kokku traageldatud, võeti appi Transformer Widget. Transformer Widget lisab OpenAjax Hub vidinatele võimaluse omavahel suhelda, kasutades semantilist integreerimist. Nähtamatute vidinate genereerimiseks loodi eraldi OpenAjax Hub vidin - Proxy Widget. See toimib teenuseid tarbivate vidinate ja tegeliku teenuse vahelise puhvrina ning lisaks hoolitseb selle eest, et vidin oleks korrektselt Transformer Widgetis registreeritud. Transformer Widgetis registreerimiseks pakub tuge ka serveripool. Serveris genereeritakse selle jaoks dokument, mis kirjeldab vidinate struktuuri ja semantikat ning lisaks ka skeem JSON vormingus andmete kirjeldamiseks. Serveripool kasutab selle jaoks teenuse semantiliselt annoteeritud WSDL keeles kirjeldust, kust saadakse kõik vajalik informatsioon. Proxy Widgeti puhverdamisloogika toimib nii, et esitluskihis võetakse sisendisse JSON vormingus andmed, mille abil luuakse JSON-RPC päring. See saadetakse edasi serveripoolele, mis omakorda transformeerib päringu SOAP päringuks ning saadab lõppteenusele. Lõppteenuselt saadud vastus teisendatakse tagasi JSON-RPC päringuks ning edastatakse Proxy Widgetile. Välja pakutud lahenduse toimimist testiti näidisrakendusega, kus esitluskihi tasemel võimaldati tarbida kolme Äriregistri teenust - firmade leidmine nime järgi, firma aastaaruannete leidmine ning aastaaruannete andmete leidmine. Näidisrakendus tõestas, et teenuste tarbimine ning andmete kuvamine osutus antud lahendusega oluliselt lihtsamaks. Lisaks oli see tõestuseks, et teenuste tarbimine oli võimalik vaid veebilehitsejale omaste tehnoloogiate kasutamisega.The Deep Web, as the name implies, is typically hidden from a common web user, because the information it contains, is not findable through standard search engines. However, this hidden information is often useful to the web user. The question is, what are the possibilities to surface those resources? An example of Deep Web resource would be a SOAP web service of Estonian Business Registry. If a developer wants to use this service in a web application, to query data about annual reports, he should create a service client on the server-side and then manually wire together the user interface and the web service. This requires quite a lot of work and knowledge of server-side programming. Following a current trend where Web application development is geared towards the browser-side implementations, what should a developer do in order to create a client-side mashup using Deep Web resources and web widgets to visualize the annual report data? Unfortunately, his possibilities narrow down quite heavily. The creation of SOAP requests on the client-side is not well supported and he should still put up a server-side proxy to request data outside his own domain. And of course, the wiring with visual widgets still requires much work. This thesis aims to provide a solution that helps a developer to create such client-side mashups. It will provide an infrastructure, that takes care of the cross-domain request problems by creating a common server-side proxy, that anyone could use. It will allow a developer to initiate SOAP requests from within a web browser, by using just JSON request data. Additionally, the solution allows a developer to integrate SOAP web services with visual widgets, by using semantic integration instead of hard-wiring

Interactive Data Sharing Mechanism for Widget-based Microsites

Tänasel veebimaastikul on kasvavaks trendiks veebilehtede vaheline sisu jagamine. Staatilise sisu asemel kasutatakse üha enam vidinaid. Vidinad on taaskasutatavad veebikomponendid, mis sisaldavad mingit konkreetset funktsionaalsust. Lihtsamad vidinad on enamasti olekuta. Keerukamad vidinad oskavad veebirakenduses omavahel suhelda, näiteks saates üksteisele sõnumeid. Nii saavad vidinad üksteist mõjutada ja seeläbi olla mashup’i laadse veebirakenduse ehitusklotsideks, määratledes selle oleku. Kuna vidinad on nõrgalt sidestunud komponendid, ei ole nad võimelised veebirakenduse olekut salvestama. Antud magistritöö pakub välja lahenduse veebirakenduse sees olevate vidinate vahetatud sõnumite jäädvustamiseks ja taasesitamiseks, võimaldades seeläbi veebirakenduse olekut salvestada ja sõpradega jagada. Lahendus baseerub jaoturipõhisel sõnumivahetusel, kasutades tehnoloogiana OpenAjax Hub raamistikku. See tähendab, et kõik ühes veebirakenduses olevad vidinad on jaoturiga ühenduses. Sõnumite salvestamiseks kasutatakse Wookie nimelist vidinamootorit, mis võimaldab luua olekuga vidinaid ja seda olekut ka salvestada. Magistritöö raames realiseeritakse iseseisev vidin, mis „sillana“ ühendab neid kaht tehnoloogiat. Sellest tulenevalt on realiseeritud vidina nimeks Wookie-OpenAjax Hub Bridge. Loodud vidin kuulab kõiki jaoturisse saadetud sõnumeid ja salvestab need andmebaasi. Kui sama vidina isend hiljem taaselustada, siis see vidin taasesitab kõik andmebaasi salvestatud sõnumid jaoturisse. 39 Realiseeritud vidina kasutamiseks luuakse väike näidisportaal, mille sees olevad vidinad omavahel sõnumeid vahetavad. Näidisportaal demonstreerib saadetud sõnumite salvestamist ja taasesitamist, ning ka oleku jagamist suhtlusvõrgustikuga Facebook.Nowadays it is very common that modern web sites exchange content between each other by means of syndication and aggregation. This is enabled through APIs, protocols, tools and platforms. The recent trend in content processing is advancing towards more extensive use of widgets along with static content. Although web sites usually use widgets to provide added value to their users, simpler web sites like microsites can be built entirely from widgets. Such kinds of widgets are usually stateless, but not necessarily autonomous. In particular they may also be able to communicate with other components in the same web application, including microsites, which are the key focus of this thesis. Because of the loose coupling, the widgets themselves are not able to capture the state of the microsite, whereas the microsite itself usually does not have a mechanism for storing its state. However, messages exchanged during communication, determine the state of the microsite. This thesis describes a solution for storing and sharing the state of a microsite by record- and-replay mechanism for messages exchanged by widgets of microsites. Furthermore, the mechanism also allows sharing the stored state of a microsite between friends via social networks. The latter enables user-initiated inter-application content delivery and state exchange, which has been possible so far only between tightly integrated applications

SECURING THE DATA STORAGE AND PROCESSING IN CLOUD COMPUTING ENVIRONMENT

Organizations increasingly utilize cloud computing architectures to reduce costs and en- ergy consumption both in the data warehouse and on mobile devices by better utilizing the computing resources available. However, the security and privacy issues with publicly available cloud computing infrastructures have not been studied to a sufficient depth for or- ganizations and individuals to be fully informed of the risks; neither are private nor public clouds prepared to properly secure their connections as middle-men between mobile de- vices which use encryption and external data providers which neglect to encrypt their data. Furthermore, cloud computing providers are not well informed of the risks associated with policy and techniques they could implement to mitigate those risks. In this dissertation, we present a new layered understanding of public cloud comput- ing. On the high level, we concentrate on the overall architecture and how information is processed and transmitted. The key idea is to secure information from outside attack and monitoring. We use techniques such as separating virtual machine roles, re-spawning virtual machines in high succession, and cryptography-based access control to achieve a high-level assurance of public cloud computing security and privacy. On the low level, we explore security and privacy issues on the memory management level. We present a mechanism for the prevention of automatic virtual machine memory guessing attacks

09141 Abstracts Collection -- Web Application Security

From 29th March to 3rd April 2009 the Dagstuhl Seminar 09141 Web Application Security was held in Schloss Dagstuhl -- Leibniz Center for Informatics. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar are put together in this paper. Links to full papers (if available) are provided in the corresponding seminar summary document

Mashic compiler: Mashup sandboxing based on inter-frame communication

International audienceMashups are a prevailing kind of web applications integrating external gadget APIs often written in the JavaScript programming language. Writing secure mashups is a challenging task due to the heterogeneity of existing gadget APIs, the privileges granted to gadgets during mashup executions, and JavaScript's highly dynamic environment. We propose a new compiler , called Mashic, for the automatic generation of secure JavaScript-based mashups from existing mashup code. The Mashic compiler can effortlessly be applied to existing mashups based on a wide-range of gadget APIs. It offers security and correct-ness guarantees. Security is achieved via the Same Origin Policy. Correctness is ensured in the presence of benign gadgets, that satisfy confidentiality and integrity constrains with regard to the integrator code. The compiler has been successfully applied to real world mashups based on Google maps, Bing maps, YouTube, and Zwibbler APIs

Mashup Ecosystems: Integrating Web Resources on Desktop and Mobile Devices

The Web is increasingly used as an application platform, and recent development of it has introduced software ecosystems where different actors collaborate. This collaboration is international from day one, and it evolves and grows rapidly. In web ecosystems applications are provided as services, and interdependencies between ecosystem parts can vary from very strong and obvious to loose and recondite. Mashups -- web application hybrids that combine resources from different services into an integrated system that has increased value from user perspective -- are exploiting services of the Web and creating ecosystems where end-users, mashup authors, and service providers collaborate. The term "resources" is used here in a broad sense, and it can refer to user's local data, infinite content of the Web, and even executable code. This dissertation presents mashups as a new breed of web applications that are intended for parsing the web content into an easily accessed form on both regular desktop computers as well as on mobile devices. Constantly evolving web technologies and new web services open up unforeseen possibilities for mashup development. However, developing mashups with current methods and tools for existing deployment environments is challenging. First, the Web as an application platform faces numerous shortcomings, second, web application development practices in general are still immature, and third, development of mashups has additional requirements that need to be addressed. In addition, mobility sets even more challenges for mashup authoring. This dissertation describes and addresses numerous issues regarding mashup ecosystems and client-side mashup development. To achieve this, we have implemented technical research artifacts including mashup ecosystems and different kinds of mashup compositions. The artifacts are developed with numerous runtime environments and tools and targeted at different end-user platforms. This has allowed us to evaluate methods, tools, and practises used during the implementation. As result, this dissertation identifies the fundamental challenges of mashup ecosystems and describes how service providers and mashup ecosystem authors can address these challenges in practice. In addition, example implementation of a specialized multimedia mashup ecosystem for mobile devices is described. To address mashup development issues, this dissertation introduces practical guidelines and a reference architecture that can be applied when mashups are created with traditional web development tools. Moreover, environments that can be used on mobile devices to create mashups that have access to both web and local resources are introduced. Finally, a novel approach to web software development -- creating software as a mashup -- is introduced, and a realization of such concept is described

Policies for Web Services

Web services are predominantly used to implement service-oriented architectures (SOA). However, there are several areas such as temporal dimensions, real-time, streaming, or efficient and flexible file transfers where web service functionality should be extended. These extensions can, for example, be achieved by using policies. Since there are often alternative solutions to provide functionality (e.g., different protocols can be used to achieve the transfer of data), the WS-Policy standard is especially useful to extend web services with policies. It allows to create policies to generally state the properties under which a service is provided and to explicitly express alternative properties. To extend the functionality of web services, two policies are introduced in this thesis: the Temporal Policy and the Communication Policy. The temporal policy is the foundation for adding temporal dimensions to a WS-Policy. The temporal policy itself is not a WS-Policy but an independent policy language that describes temporal dimensions of and dependencies between temporal policies and WS-Policies. Switching of protocol dependencies, pricing of services, quality of service, and security are example areas for using a temporal policy. To describe protocol dependencies of a service for streaming, real-time and file transfers, a communication policy can be utilized. The communication policy is a concrete WS-Policy. With the communication policy, a service can expose the protocols it depends on for a communication after its invocation. Thus, a web service client knows the protocols required to support a communication with the service. Therefore, it is possible to evaluate beforehand whether an invocation of a service is reasonable. On top of the newly introduced policies, novel mechanisms and tools are provided to alleviate service use and enable flexible and efficient data handling. Furthermore, the involvement of the end user in the development process can be achieved more easily. The Flex-SwA architecture, the first component in this thesis based on the newly introduced policies, implements the actual file transfers and streaming protocols that are described as dependencies in a communication policy. Several communication patterns support the flexible handling of the communication. A reference concept enables seamless message forwarding with reduced data movement. Based on the Flex-SwA implementation and the communication policy, it is possible to improve usability - especially in the area of service-oriented Grids - by integrating data transfers into an automatically generated web and Grid service client. The Web and Grid Service Browser is introduced in this thesis as such a generic client. It provides a familiar environment for using services by offering the client generation as part of the browser. Data transfers are directly integrated into service invocation without having to perform data transmissions explicitly. For multimedia MIME types, special plugins allow the consumption of multimedia data. To enable an end user to build applications that also leverage high performance computing resources, the Service-enabled Mashup Editor is presented that lets the user combine popular web applications with web and Grid services. Again, the communication policy provides descriptive means for file transfers and Flex-SwAs reference concept is used for data exchange. To show the applicability of these novel concepts, several use cases from the area of multimedia processing have been selected. Based on the temporal policy, the communication policy, Flex-SwA, the Web and Grid Service Browser, and the Service-enabled Mashup Editor, the development of a scalable service-oriented multimedia architecture is presented. The multimedia SOA offers, among others, a face detection workflow, a video-on-demand service, and an audio resynthesis service. More precisely, a video-on-demand service describes its dependency on a multicast protocol by using a communication policy. A temporal policy is then used to perform the description of a protocol switch from one multicast protocol to another one by changing the communication policy at the end of its validity period. The Service-enabled Mashup Editor is used as a client for the new multicast protocol after the multicast protocol has been switched. To stream single frames from a frame decoder service to a face detection service (which are both part of the face detection workflow) and to transfer audio files with the different Flex-SwA communication patterns to an audio resynthesis service, Flex-SwA is used. The invocation of the face detection workflow and the audio resynthesis service is realized with the Web and Grid Service Browser

Middleware Technologies for Cloud of Things - a survey

The next wave of communication and applications rely on the new services provided by Internet of Things which is becoming an important aspect in human and machines future. The IoT services are a key solution for providing smart environments in homes, buildings and cities. In the era of a massive number of connected things and objects with a high grow rate, several challenges have been raised such as management, aggregation and storage for big produced data. In order to tackle some of these issues, cloud computing emerged to IoT as Cloud of Things (CoT) which provides virtually unlimited cloud services to enhance the large scale IoT platforms. There are several factors to be considered in design and implementation of a CoT platform. One of the most important and challenging problems is the heterogeneity of different objects. This problem can be addressed by deploying suitable "Middleware". Middleware sits between things and applications that make a reliable platform for communication among things with different interfaces, operating systems, and architectures. The main aim of this paper is to study the middleware technologies for CoT. Toward this end, we first present the main features and characteristics of middlewares. Next we study different architecture styles and service domains. Then we presents several middlewares that are suitable for CoT based platforms and lastly a list of current challenges and issues in design of CoT based middlewares is discussed.Comment: http://www.sciencedirect.com/science/article/pii/S2352864817301268, Digital Communications and Networks, Elsevier (2017