DESIGN AND IMPLEMENT AND ONLINE EXERCISE FOR TEACHING AND DEVELOPMENT OF A SERVER USING SOCKET PROGRAMMING IN C

Transcription

1 DESIGN AND IMPLEMENT AND ONLINE EXERCISE FOR TEACHING AND DEVELOPMENT OF A SERVER USING SOCKET PROGRAMMING IN C Elena Ruiz Gonzalez University of Patras University of Granada ERASMUS STUDENT:147 1/100

2 Table of Contents 1 Introduction Motivation Objectives State of art Environment and development platforms Design & Implementation Introduction of the socket tools Function socket Communication domains Types of sockets Order of bytes Creating a socket Sockets address Association of sockets to certain parameters Connection oriented service (TCP) Enable a socket for connection requests Accept connection requests Launch connection requests Connection between client-server sockets Send and receive data through a TCP sockets State diagram of a TCP connection Closing a socket Analysis of resolution Functional requirements ForgeBox managing services Specification of software requirements Functional requirements Non-functional requirements User Cases Design of the solution Client-server model Creation of server Problems. Multi-servers Creation of the client Interface design First curse. Presentation part Second module. Interactive course Third module. Interactive course Fourth module. Course presentation part Compilation and execution model through remote servers /100

3 5.5.1 Creating our jfed scenario RSpec file creation Technologies applied Conclusion and future work Conclusion Future work Appendix Server.c Server1.c Server2.c Server3.c Client.c RSpec Bibliography and reference /100

4 1 Introduction 1.1 Motivation Learning to program is a very complex task that requires the acquisition of knowledge and skills and that cannot be accomplished without the student's own experimentation. The practical part of the subjects in programming is very important, even more than the lectures, since it is when students demonstrate their understanding and internalization of the theoretical concepts. One wonders if the way you learn to program is the most appropriate. Currently students use during their practical lessons the same kind of tools used by professional programmers, although the latter is a very general statement, since these programmers use a wide range of tools and options. The main idea is that students end up using these tools; hence it seems natural that they use them from the beginning. In this paper we have explored the advantages of an interactive environment (FORGE) to learn how to implement a server and client, not only to program, and how to address problems that can arise during implementation and resolve them by oneself. Therefore, what is proposed in this paper is the design and implementation of an environment that, by its nature, is not limited to be a simple development environment, but comprises unique features that include educational guidance specially designed to learn to manage certain tools such as sockets. The following summarizes the main reasons for choosing a web environment as FORGE: The non-dependence on operating systems, since multiplatform execution is achieved through web browsers. The power to monitor our activity (students) when performing exercises at home as the histories of access to the application are saved. Being web-based, remote access is allowed. 4/100

5 1.2 Objectives The main objective of this Final Project is to carry out the design and implementation of exercises with the FORGE platform so that it provides the necessary infrastructure to help students learn how to implement a server and client using sockets in c. This goal can be broken down into several points that are as follows: Students will be able to access the course they want to perform. In our case they can choose the course of implementing a server and client using sockets in c. They will learn in a simple and didactic way to implement (with the help of the given indications), compile and run the process and how to face different problems that can occur in a real situation, learning to identify and solve them. This will provide an accessible environment via the Internet allowing students not to have to worry about the installation, the architecture of the machine, where they are programming or the operating system, which are some of the drawbacks of most programming environments. Thus, it can be used independently of the platform (Unix / Linux, MacOS, Windows, etc.). This greatly facilitates the work for the students if they want to work from home, since they do not need to install the environment on each machine they intend to use with the compatibility problems this might cause (for example, in many subjects the Dev-C ++ program in a Windows environment is used and some students use other operating systems). As an additional task, it will be possible to supplement the programming course with sockets, with short test questions or brief comprehension statements. It will offer a different way of programming in which statements will be merged with practical exercises and theoretical questions in one document all visible to the users of the application. That is, the tool can also be used to display notes on the theory where the readers can test the examples. It will provide real-time interaction of students with the program by means of the terminal of the web environment. 5/100

6 2 State of art 2.1 Environment and development platforms. Currently, in most courses and subjects of introduction to programming, students use a fairly professional environment, but this has not always been the case. Formerly there were no integrated development environments and the student had to manage with a simple text editor and a compiler that could be used independently. With the evolution of programming languages and the need to create software, educational development environments have emerged. These tools have their pros and cons in terms of usability in the field of programming. The use of these environments in performing practices sessions has benefits, since they allow students to become familiar with a professional environment. In addition, an integrated development environment usually brings together a number of tools such as: a text editor, a compiler, and a version controller... All this makes the environment a powerful tool for those who know how to use it. On the other hand integrated development environments have drawbacks for a beginner programmer. These problems are directly related to the amount of utilities they offer, since professional environments frequently need specialized courses in order to learn how to use the tool. Usually it is assumed that students already know some programming language and what is required is the speeding up of the task of programming by using the built-in environments. What for a professional programmer can be an advantage for a beginner can become a disadvantage because the environment acts as a barrier between the task of learning and the student who has to make a double effort: learn to program and learn to use the programming environment. There is an increasing tendancy to facilitate the task of programming of an inexperienced student with the use of environments that are easy to configure and manage. The teacher currently plays an important role in the execution of the practice sessions of students. Traditionally, the teacher s role has been limited to the development of a bulletin with the statements of the practice sessions. In some cases, the student had to start from scratch while in others the teacher will provide a template to fill in. It is noteworthy that, in many cases, the teacher has little capacity to decide the environment, which can be imposed by limitations in the choice of the operating system. But this would no longer be the case since one of the advantages of the development of our online course platform FORGE is that the activity of the student when performing exercises at home can be monitored, as the system records the history of access to the resources. Having a test mode and to use the environment even for distance learning are also possible. Today there are countless applications that support teaching. For instance we can mention PoliformaT (Sakai project) and Moodle, amongst others. Moodle is software designed to help educators create online courses and virtual learning environments. Such online learning systems are sometimes called VLEs (Virtual Learning Environments) or virtual learning environments. 6/100

7 In recent years, distance courses have boomed due to online platforms for conducting these courses. These courses for the community in general are known as Massive Online Courses (Massive Open Online Course (MOOC)). There are several platforms (and constantly increasing) that teach these courses. In addition many of them are directly related to the field of computing and, in particular, of programming. The number of courses that are offered online, both officially and unofficially, is very high. Therefore, in this section we will only focus on those online platforms designed for learning to program in an educational environment or those that are closely related to programming. We shall obviously only highlight those that exhibit environments for writing and executing code online, using a browser. The courses and platforms available specifically designed for programming can be divided into 3 types: 1. -Those where the code is developed locally (on the user s own machine), it runs locally and the solution is verified by sending the answer via a web form. In this case, the user downloads the code, or a set of files (if appropriate), edits the code and runs the program on their machine with the data that has been provided. Then, using a web-form, the user sends the solution after executing the cases. Usually the material accomplished by the distance learner is sent to the teachers who are responsible for reviewing the work. These platforms do not have any execution or online edition. The web environment itself only serves to verify the solution and to show the course content (videos, slides, manuals, etc...). 2. -The code is executed via the Web on the client s side. You write the code in the browser and the results are shown on the web interface itself. This system is quite common in web programming courses: HyperText Markup Language (HTML), Cascading Style Sheets (CSS), JavaScript and other web languages, where the code can easily be run on the client s side. There are other more complex systems that allow translation of the code of a particular language (C, C ++) to Javascript and to run it in the same browser. This is the case of the combination of a compiler that generates the code of a LLVM virtual machine (for example, the compiler clang) with the compiler of LLVM to Javascript denominated Emscripten. This allows you to run programs on the client side written in C. This also applies to the well known Java applets, which allow the user to run Java code in a browser Those that the code that runs on the server and the results are displayed on the client side. This service allows the highest flexibility, since the server has all the necessary components for running the user code and the user does not have to worry about installing the necessary libraries. There are also several ways of treating the code ellaborated by the user. In certain cases a function is requested, and the system checks if it has been completed correctly by hidden test cases. Other platforms have the option of running a terminal, usually using interpreted languages (Python, Javascript), and carrying out interactively executions of the developed code. In some programming contests, it is possible to run the program developed by using an entrance designed by the user. In any case, the execution is performed on the server and non-interactively. Although we have focused in the present case on providing a support platform to facilitate learning programming, in our case in the utilization of sockets, it is interesting to describe different online platforms and MOOC 's dedicated to provide education through web resources (slides, videos, etc.). 7/100

8 The most prominent MOOC 's platforms are Udacity and Coursera. Both have several courses teaching different subjects, most of which are focused on topics of computer science and, in particular programming. In mid-2011, Stanford University, presented a series of online courses on the use of certain oriented programming tools that were completely free. Although they were not the first courses offered in this format, they were widely accepted by the online community. The courses were taught by prestigious teachers, thus the Artificial Intelligence course was presented by Peter Norvig (renowned researcher in AI) and Sebastian Thrun; and machine learning was directed by Andrew Ng. Later on, the number of courses offered expanded, and included options such as Algorithms (Tim Rougharden), Natural Language Processing (Daniel Jurafsky and Chris Manning), Modeling (Daphne Koller) and others. Although initially there was no unified technology platform, the courses usually consisted in videos, questions (Included or not in the videos) and a section of multiple choice questions or problems, as well as tests that were evaluated automatically. The practical part, which is what interests us, usually develops toolkits using downloadable programs where the user must fill in the missing pieces of code, and then send the results using the same executable downloaded or complete a form on the website. Due to the popularity of these courses amongst the online community, simultaneously two platforms were created just to teach various courses using an online format: Udacity and Coursera. There are several differences between the two platforms, both in terms of content and in terms of the tools. Still, it is noteworthy that Coursera included courses presented by various teachers from different universities around the world, while Udacity includes courses that are often taught by professors from prestigious universities, however they are not directly linked to any university. In computer-related courses both platforms provide different mechanisms for evaluating the exercises where programming is required. Coursera still contains downloadables with the code, where the user must have the necessary tools on his computer. Udacity includes a web editor (in principle for Python language) where the user develops its code and runs it on a number of hidden cases and where the user is shown the result of the implementation: if you are right or not. Typically, the code is done after developing a lesson (or video) in order to secure contents. Lately, a wide variety of online education platforms have emerged, including platforms in Spanish such as Miriadax. Khan Academy should also be mentioned, which was founded earlier than those shown above (2006), and included courses in various specialties: computer courses, oriented programming and network configuration. The platform provided an intuitive interface for displaying results in a visual way that helped to understand the course content. Apart from these online schools, there are many other web platforms, which have a variety of courses, most of them related to computers and development in general. Examples are the following: Codeacademy is an online platform created exclusively for teaching programming in different languages. It includes courses for Python, Javascript, HTML, CSS, etc. This platform was created in 8/100

9 September 2011 and the courses are completely free. The interface is quite intuitive and the Web-based courses (HTML, CSS, Javascript) allow for the visualization of the results of the exercises in the environments and development platforms of the browser. One of the few drawbacks of the platform is that it is sometimes difficult to identify errors, especially in HTML and Javascript. Udemy includes courses on different subjects: business management, art, health, languages, music, and technology. As a remarkable feature, instructors can create courses using the platform and can upload additional contents for courses such as transparencies, videos or others. On the platform there are many free courses, although some have a charge which varies between $ 5 and $ 250. Codelearn has different free programming courses. This platform has a powerful web interface that allows you to create and execute code on the same platform. Learncode is designed to reduce the gap between the knowledge learned in college/school and the demands in programming of the real world. An important detail of the platform is that there is a section called "Code Garage" where you can create more complex projects step by step such as a Sudoku, Tic Tac Toe, Minesweeper and more. Codeschool is very similar to the previous platform. It has a lot of courses, mostly oriented towards web development technologies (Javascript, jquery, CSS3, etc) although it also includes more general tutorials such as Git Hub, IOS or Unix. Google also has its own platform for online courses, although these courses are more oriented to mobile platforms (Android) instead of teaching how to program from scratch. On the other hand, it includes programming contests and/or algorithms which aim at solving problems of different degress of difficulty by programming. Although these contests are not intended to teach programming from scratch, there are several websites where problems are presented sorted by difficulty, so you can access these sites to reinforce the already known programming concepts and find an application of the proposed problems. Regarding the web pages and sites the following are worthy of mention: Codeforces, TopCoder, Checkio, USA Computing Olimpiad, Codechef,... Of the sites shown, Check.io is notable for its interface, and its way of showing programming problems as a game where problems of increasing difficulty are solved in order to advance the story. In addition in a similar fashion to the tool presented in this project, it provides a fully online editor (in this case for Python), where the user is able to run the code on the server but visualizes the results on a web interface. After this summary on information regarding the different platforms, online courses and web environments, now we shall formulate the most important question: why use the Forge platform? Forge allows to study and develop new processes and approaches to online learning based on the integration of FIRE facilities and elearning technologies. It injects into the higher education learning sphere the FIRE portfolio of facilities and tools. It introduces the learning community to the concepts of experimentally driven research and increases the overall accessibility and usability of FIRE facilities through the layering of how-to-use resources over the FIRE platforms. The Future Internet Research and Experimentation (FIRE) initiative is intended to ensure that the European Internet Industry evolves towards a Future Internet containing European technology, services 9/100

10 and values. Through the FIRE initiative and other similar regional and global initiatives a variety of facilities have been established to enable such experimentation. These facilities cover a plethora of different domains belonging to the Future Internet ecosystem, such as cloud computing platforms, wireless and sensor network testbeds, Software Defined Networking and OpenFlow facilities, infrastructures for High Performance Computing, Long Term Evolution (LTE) testbeds, smart cities and so on. However, the corresponding cost both for the establishment and operation of these infrastructures is not to be neglected. Hence optimal usage of the facilities is desired by its owners, a goal which in general is not yet achieved today. To increase the usage, several steps can be taken. One approach is to raise the awareness of the facilities within communities that are less familiar with the FIRE initiative. Another is to use the infrastructure not only for research and development, but also for other activities such as teaching through a constructivist approach. This means that students would be enabled to take certain initiatives in their learning, by setting up and conducting scientific experiments based on FIRE. In this way, using FIRE facilities for teaching computer science topics or other scientific domains would not only increase the usage of the facilities, it would also raise FIRE awareness in the long term since the students/experimenters of today are the researchers of tomorrow. And if educational materials were available that actually enable new types/areas of experimentation through FIRE, this would further lower the threshold for experimenters to explore new facilities and technologies. FIRE has invested significantly in the last few years in creating its federation. FIRE strives for a harmonization of tools and APIs to facilitate experimentation and the integration of heterogeneous resources around a single experiment under a single account and by using any experimentation tool that the end user wants. All this effort is currently led by FIRE s flagship project, Fed4FIRE (Integrated project, number , funded by the European Commission through the 7th ICT- Framework Programme, 1 Oct Sep. 2016). FORGE will build upon Fed4FIRE s leadership using the project as our main channel to the FIRE facilities. FORGE will thus adopt Fed4FIRE s tools and proposed mechanisms to aid in our role as an intermediary between the learning community and the FIRE facilities and tools. More specifically, we will adopt the Authentication Authorization Identification mechanisms and the tooling and additionally the APIs targeting experimenters and facilities. FORGE will investigate if these mechanisms can be applied as is or suggest extensions to our Fed4FIRE colleagues (as it is within Fed4FIRE s scope to collect requirements from the FIRE community). In some cases FORGE will also implement wrappers around Fed4FIRE s processes and mechanism in order to ease access to the learning community. For example there might be some fine-grained scheduling needs in FORGE that Fed4FIRE mechanisms do not take into account (e.g. limited time for a group of students to jointly complete a certain task). In such cases FORGE will develop the required mechanisms. The FORGE core will create a set of processes, tools and widgets to facilitate the development of lab courses. The pilot prototype lab courses will generate requirements for learning tools along a number of dimensions including overall functionality and interaction qualities. Especially, during the integration phase with the Learning Management System (LMS) of Lab Course creators, a validation of the development tools will be carried out. Followed by the execution of the Lab Courses where the final validation of the whole FORGE process will be finalized. As explained above, the FORGE core, driven by the requirements of the pilot prototype lab courses, will deliver a set of processes and tools to the learning community. To broaden the scope and the usage of the FORGE utilities, an expansion phase is planned by opening up the platform when starting the second half of the project by issuing an open call which will last for the rest of the project duration. We 10/100

11 expect volunteers from the learning community and elsewhere, who want to exploit FIRE facilities for educational purposes, to contribute to the FORGE ecosystem. The project consortium will support these community-driven courses by implementing requested widgets, tools and APIs, to the best of its ability, considering its limited budget and resources. 11/100

12 3 Design & Implementation Once the behavior of the application is specified, it is necessary to go into the details of the implementation and the technologies to be used to carry out the development of our online course. This design phase is very important because it is the creative part in which the designer defines how the course will be held in terms of implementation and design. It must be kept in mind that course design and implemention are completely different terms, so in the course design what must be implemented is explained, but not how it should be developed. For the course design we shall use several tools. This chapter will explain the design of the course. First we will make a brief introduction about socket programming. We shall discuss the code used to create our client-server scenario. Later on, we shall see how it is created and implemented in the e-learing platform used (Forge) and the compilation and execution model used, as it is important to bear in mind this is an application that allows the execution of programs created by users. 3.1 Introduction of the socket tools. Sockets are one of the tools that operating systems provide for communication between different processes. The particularity that they present with respect to other communication mechanisms (IPC - Inter-Process Communication) is that communication is possible even when both processes are running on different systems connected by a network. In fact, the sockets API is the basis of any application that runs on a network because it offers a library of basic functions that programmers can use to develop network applications. This API allows communication over a variety of networks, but in this manual we will focus on the use of TCP / IP networks. Sockets for TCP / IP allow the communication between two processes that are connected via a TCP / IP network. In a network of this type, each machine is identified by its IP address that must be unique. However, each machine may be running multiple processes simultaneously. Each of these processes is associated with a port number, in order to distinguish the different packages that the machine is recieving (the process of multiplexing). A socket is uniquely identified by an IP address + port number pair. A communication between these two processes is identified by associating these sockets used to send and receive information to and from the network: identifier of the origin socket + identifier of the destination socket. The information is very similar to how you write and read from a file. The information that an application sends through the origin socket can be received by another application through the destination socket and vice versa. There are different types of sockets depending on the protocol stack used for creating the socket. We will focus on the TCP / IP protocols. 12/100

13 The logical relationship between applications, sockets, protocols and ports in a device. There are several things to note about this relationship. First, a program may use more than one socket at the same time. Second, different programs can use the same socket at the same time although this is less common. As shown in the figure, each socket is associated with a TCP or UDP port, as appropriate. When a packet addressed to that port is received, the packet is passed on to the corresponding application. 3.2 Function socket. This section describes some aspects that are necessary to know when working with sockets Communication domains. The sockets are created in what is called a communication domain which defines which protocol stack will be used in the communication. The domains that are defined in the C language are: Domain PF_UNIX, PF_LOCAL PF_INET PF_INET6 PF_IPX PF_NETLINK PF_X25 PF_AX25 PF_APPLETALK PF_PACKET PF_ATMPVC Purpose Processes that communicate through the same UNIX system Processes that communicate using a IPv4 network Processes that communicate using a IPv6 network Processes that communicate using a Novell network Communicataion with kernel processes ITU-T X.25 / ISO-8208 protocol Amateur radio AX.25 Appletalk Access to PVCs ATM Access to PVCs ATM 13/100

14 3.2.2 Types of sockets. In the PF_INET domain, the following types of sockets are defined: Stream Sockets Datagram Sockets Raw Sockets A TCP Stream socket uses the TCP protocol (protocol of the transport layer) that provides bidirectional data flow, connection-oriented, sequenced, without duplication of packets and error free. If we send by the stream socket three objects "A, B, C", they arrive at the destination in the same order "A, B, C". These sockets use TCP ("Transmission Control Protocol") and it is this protocol that ensures the order of objects during transmission. Datagram sockets make use of the UDP Protocol (protocol of the transport layer), which provides a bidirectional data flow, which is not connection-oriented and where packets may arrive out of sequence, packets may be lost or errors might occur. They do not need an accessible connection such as stream sockets; a data packet will be built with destination information and then sent out. Raw sockets allow a lower access level, they can directly access the IP network layer protocol. Their use is much more limited because they are mainly used for developing new communication protocols to obviate the transport layer protocols. 3.3 Order of bytes A peculiarity of the operating systems is the way they store the bytes in memory. To avoid mistakes, the TCP / IP protocol defines a sequence of bytes that is independent of the machine. This byte order is called the order of network (network byte order) and considering its own definition it is equivalent to the order known as big-endian. If working on a Big-endian machine, this factor does not have to be taken into account, however, when working on Little-endian machines, you must have the information in the network order. htons () - host to network short - Converts a short int from machine format to network format. htonl () - host to network long - Converts a long int from machine format to network format. ntohs () - network to host short - Converts a short int from network format to machine format. ntohl () - network to host long - Converts a long int from network format to machine format. 14/100

15 It may be that the system used for programming stores the data in network byte order and no conversion is necessary. But if we try to compile the same source code in another platform host byte order, it will not work. Example: #include <netinet/in.h>... port = htons ( 3490 ); Creating a socket Analogy: For a person to receive calls you must have a phone, to make a connection you must create a socket. #include <sys / types.h> #include <sys / socket.h> #include <netinet / in.h> int socket (int domain, int type, int protocol); Sockets are created by calling the socket () function, which returns the socket identifier, whole number type (equivalent to the concept of file identifier). In the event that an error occurred during the creation of the socket, the function returns -1 and the global variable errno is set to a value that indicates the error that occurred. The function perror ("...") prints out an explanatory message on the error that has occurred. The format of the socket function ()is as follows: sockfd = socket (int domain, int type, int protocol); sockfd: socket ID. It will be used to connect, receive connections, send and receive data, etc. Domain: Marketplace where the connection is made. For this practice, the domain will always be PF_INET. 15/100

16 type: It corresponds to the type of socket that is going to be created, and can take the following values (defined as constants in libraries): SOCK_STREAM, SOCK_DGRAM protocol: Specifies the protocol to be used. A value of 0 indicates that the most appropriate protocol is to be selected (TCP for SOCK_STREAM, SOCK_DGRAM UDP). An example of its use: #include <stdio.h> #include <sys / types.h> #include <sys / socket.h>... int sockfd; sockfd = socket (AF_INET, SOCK_STREAM, 0); Sockets address. The socket () function only creates a socket, but does not assign any value, that is, it does not associated it with any IP address or any port. To perform this association, you must first know a series of structures that are necessary. struct sockaddr { unsigned short sa_family; // PF_* char sa_data[14]; // Dirección de protocolo. ; struct sockaddr_in { short int sin_family; unsigned short sin_port; // PF_INET // Numero de puerto. // Dirección IP. struct in_addr sin_addr; unsigned char sin_zero[8]; // Relleno. ; struct in_addr { unsigned long s_addr; // 4 bytes. 16/100

17 The sockaddr structure is the generic structure used in different functions defined in the Sockets API. As can be seen, it only defines the domain while the data (socket parameters) are unspecified (it simply reserves memory space, but without any structure). This allows the structure to be used independently of the domain that has been used to define the socket. In order to define the parameters that you want to associate with the socket, specific structures for each domain are used. The TCP / IP sockaddr_in structure is equivalent to the sockaddr structure, but allows reference to its elements more easily. The fields of sockaddr_in structure are: sin_family: will always take the values PF_INET. sin_port: Represents the port number, and must be in the order of bytes of the network. sin_addr: This field represents the IP address, and is stored in a specific format. To convert an IP address in text format to an unsigned long with an appropriate order of bytes, the inet_addr().unsigned long function is used. This function converts only IP addresses to a numeric format, it does NOT convert machine names. In case of error, -1 is returned and the errno global variable is activated. Example:... struct sockaddr_in sin;... sin.sin_addr.s_addr=inet_addr(" "); The inverse function is called inet_ntoa (), which converts an address in numeric format to a string of characters. Example:... printf("%s", inet_ntoa(sin.sin_addr));... - sin_zero: It is used only to complete the length of sockaddr. 17/100

18 3.4.2 Association of sockets to certain parameters. #include <sys/types.h> #include <sys/socket.h> int bind(int local_s, const struct sockaddr *addr, int addrlen); The bind () function is used to associate with these parameters an IP address and a port number of the local machine through which data is sent and received. Analogy: To receive a call, you must have a phone number; in order to receive connections, you must assign a name to the socket. You need to call bind () when programming a server. When programming a client. this function is not usually used. The kernel will assign the socket an IP address and the port number available when calling certain functions, for example when calling connect () to get connected to a remote system. On the server you need to call bind () because the port number must be known so that clients can connect. For example if you are programming a telnet server you should call bind () to assign the socket port. In the client application you can call bind () and assign a port number, but this is not necessary because no one will be able to get connected.. The format of the function is as follows: int bind(int sockfd, struct sockaddr *my_addr, int addrlen); sockfd : socket identifier returned by the socket function (). my_addr: It is a pointer to a sockaddr structure containing the local host IP and the port number to be assigned to the socket. addrlen: It must be set to the size of the sockaddr structure: sizeof (struct_sockaddr). Example:... struct sockaddr_in sin;... ret = bind (sockfd, (struct sockaddr *)&sin, sizeof (sin)); if(ret < 0) perror( Error binding the socket ); /100

19 Prior to the call to the bind function () it is necessary to assign values to a variable of type sockaddr_in which will be the parameters associated to the socket. There are some special cases when assigning values to certain fields. If you assign zero to sin_port, the system sets the port number to the first available. To assign the IP address automatically (without having to know beforehand the IP address where the program will be run) the constant: INADDR_ANY can be used. This tells the system that the program will receive messages through any valid IP of the machine, in the case that several would exist. Example:... sin.sin_port = 0; sin.sin_addr.s_addr = htonl (INADDR_ANY);... Importantly, all socket functions expect to receive as parameter a pointer to a sockaddr structure, so it is necessary to perform a type conversion (cast) to this type, as has been done in the previous example. The bind function () (similar to the socket function (), and in general all the functions related to sockets) returns -1 when there has been any error condition, and sets the global variable perror () to the number of the error, so that the perror () function can be directly invoked to display it on screen. 3.5 Connection oriented service (TCP). The following describes the steps required to create a connection- oriented service, both on the client and the server-side. The steps to accomplish this are shown for both cases, invoking different functions, although details will be provided below. 19/100

20 Client Connection- oriented service (TCP) Server socket() bind() listen() accept() socket() [bind()] connect() send() recv() recv() send() Both client and server must create a socket by using the socket () function, in order to communicate. The call to the bind () function of the client is optional because if not invoked, the system will automatically run it and assign it a free port (random). On the other hand, in the server, the call to the bind function is required in order to reserve a specific known port. The server enables the socket to receive connections, calling the listen () function. In the client this step is not necessary because it will not receive connection requests from other processes. The server executes the accept () function and remains in standby until a client gets connected. The client uses connect () to attempt the connection. At that time the accept () function of the server returns a parameter that is a new socket identifier, which is used to transfer data across the network to the customer, thus leaving open the socket previously created to satisfy new requests. Once the connection is established the send and recv () functions are used with the socket descriptor of the previous step, in order to perform the data transfer. To end the connection the close () function is used. Below the calls to all these functions are described in detail. 20/100

21 3.5.1 Enable a socket for connection requests. #include <sys / socket.h> int listen (int sockfd, int backlog); The first step for communication using a connection-oriented service (TCP transport protocol) is the establishment of a TCP connection. In this sense, even if you have created a SOCK_STREAM socket type, the socket is not prepared to make such connection. To enable a socket for connection requests and proceed to the establishment of such a connection, you must use the listen () function. The listen () function is invoked only from the server, and enables the socket to receive connections. It applies only to sockets of the type SOCK_STREAM. The format of the function is as follows: int listen (int sockfd, int backlog); sockfd: socket identifier obtained in the socket () function, which will be used for connections. backlog: Maximum number of connections in the input queue of connections. Incoming connections are on standby in this queue until they are accepted by the accept () function Accept connection requests. #include <sys / types.h> #include <sys / socket.h> int accept (int sockfd, struct sockaddr * addr, socklen_t * addrlen); While the listen () function sets the socket and enables it to receive requests for connection establishment, it is the accept () function that actually waits for these requests. When a request made from a remote process (client) is received, the connection is completed on the server as long as it is waiting in the accept () function. The accept () function is used on the server once the listen () function has been invoked. This function waits until a client establishes a connection with the server. It is a blocking call, that is, the function does not end until a connection has occurred or it is interrupted by a signal. It should be stressed that once there has been a connection, accept () returns a new socket identifier to be used for communication with the client is connected. 21/100

22 The format of the function is as follows: int accept (int sockfd, struct sockaddr * addr, socklen_t * addrlen); sockfd: socket ID enabled to receive connections. addr: Pointer to a sockaddr structure (in our case its equivalent sockadd_in), where the information (IP address and port number) of the process that has performed the connection will be stored. addrlen: It must contain a pointer to a whole value representing the size of the addr structure. It must be set to the size of the sockaddr structure, by calling sizeof (struct sockaddr). If the function writes a smaller number of bytes, the value of addrlen is modified to the number of bytes written. Example:.. int sockfd, new_sockfd; SERVER_ADDR sockaddr_in; remote_addr sockaddr_in; int addrlen; // Create the socket. sockfd = socket (AF_INET, SOCK_STREAM, 0); // Set values in SERVER_ADDR structure. server_addr.sin_family = PF_INET; server_addr.sin port = htons (1234); // Port number where server_addr.sin_addr.s_addr = htonl (INADDR_ANY); // Get the program packages // Attach the socket defined values bind (sockfd, (struct sockaddr *) & SERVER_ADDR, sizeof (struct sockaddr)); // The socket to receive connections is enabled. listen (sockfd, 5); 22/100

23 addrlen = sizeof (struct sockaddr); // You call accept () and the server is waiting for connections. new_sockfd = accept (sockfd, & remote_addr, & addrlen); Launch connection requests. #include <sys / types.h> #include <sys / socket.h> int connect (int sockfd, const struct sockaddr * serv_addr, socklen_t addrlen); This function is invoked from the client to request the establishment of a TCP connection. The connect function() initiates the connection to the remote server of the client. The format of the function is as follows: int connect (int sockfd, struct sockaddr * serv_addr, int addrlen); sockfd: socket identifier returned by the socket () function. serv_addr: sockaddr structure containing the IP address and destination port number. addrlen: It must be initialized to the size of the serv_addr structure passed as parameter. Example:... int sockfd; SERVER_ADDR sockaddr_in; int addrlen; // Create the socket. sockfd = socket (AF_INET, SOCK_STREAM, 0); // Set values in SERVER_ADDR structure. server_addr.sin_family = PF_INET; 23/100

24 server_addr.sin port = htons (1234); // Port number where // You are waiting for the server server_addr.sin_addr.s_addr = inet_addr (" "); // IP address // Server addrlen = sizeof (struct sockaddr); // It calls connect () and makes the connection request to the server connect (sockfd, & SERVER_ADDR, addrlen); Connection between client- server sockets. Once the customer has made the call to connect () and this has been successfully completed (which means that the server was waiting in the accept () function and has left this state and thus created the new socket), the situation is as shown in the Figure: Server Client Sockfd New_Sockfd Sockfd Sockets TCP TCP IP Port TCP TCP IP Figure 1: Sockets, protocols and port. 24/100

25 As shown in the figure, a connection between the socket used by the client in the connect () function and the socket returned by the accept () function is created in the server. This connection will allow communication between two processes using sockets that are connected Send and receive data through a TCP sockets. #include <sys / types.h> #include <sys / socket.h> ssize_t send (int s, const void * buf, size_t len, int flags); Once the connection has been established, data exchange is initiated, using the send ()and recv ()functions. The format of the function send () is as follows: ssize_t send (int sockfd, const void * buf, size_t len, int flags); sockfd: socket identifier to send data. buf: A pointer to the data to be sent. len: Number of bytes to send. flags: By default 0. For more information, consult the online help. The send () function returns the number of bytes sent, which may be less than the amount indicated in the len parameter. The recv () function is used to receive data, and has a format similar to the above: ssize_t recv (int sockfd, void * buf, size_t len, int flags); sockfd: socket identifier for receiving data. 25/100

26 buf: A pointer to a buffer where the received data is stored. Len: Maximum number of bytes to receive. Flags: modify the behavior of the receiving function. For default behavior, set the parameter to 0. The recv () function is blocking, and does not end until it has received some kind of information. It is important to highlight that the len field indicates the maximum number of bytes to be received, but not necessarily this exact number of bytes has to be received. The recv () function returns the number of bytes that have been received. Example:... mens_serv char [100];... mens_clien = "Example"; send (sid, mens_clien, strlen (mens_clien) +1, 0);... recv (sid, mens_serv, 100, 0); State diagram of a TCP connection. The previous figure shows the states a TCP connection can go through. The events and segments that are exchanged in each transition from one state to another are also indicated. As can be seen, when created, a socket is in the CLOSED state. There are two ways of leaving this state: by an active or a passive opening. While the first occurs on the client side when it performs the call to connect () and with it begins the process of establishing the connection, the second occurs at the server once the calls to the listen () and accept () are performed. Thus, on the server the socket used for receiving connection establishment requests changes to the LISTEN state, and waits until the process of establishing the connection is initiated on the client side. After establishing the connection, both the socket created by the client and the socket that returns the accept () function change to the ESTABLISHED state. The socket used by the server to receive requests for connection establishment continues in the LISTEN state. 26/100

27 Data exchange takes place between the sockets that are in the ESTABLISHED state. Once completed, both sockets go to the CLOSED state (after going through a series of intermediate states). The event that causes this closure is the call between both processes (client and server) to the close () function. 3.6 Closing a socket. #include <unistd.h> int close (int fd); You just have to make the call to the function giving as argument the socket descriptor that needs to be closed. It is important that when a socket is not going to be used anymore, the close () call should be performed in order to give indications to the operating system that it must be released. 27/100

28 4 Analysis of resolution. 4.1 Functional requirements. To understand the full operation of the FORGE tool, it is necessary to perform a complete description of the software requirements that define the behavior of the tool, as well as the use cases. A software requirement describes the behavior of a system. The requirements can be divided into two types, the first is the functional requirements that define the internal behavior of the software, whose interactions are described by the use cases. The second type is the non-functional or complementary requirements. The software requirements of the application will be presented. A very important consideration when describing the software is that there is no ambiguity in the terminology used. Therefore, the main terms used to describe the course that are being developed will be explained: User - Is anyone using this tool. Teacher or creator of the course Is the person in charge of defining and creating the content of the training course for students. It is considered a system user. Student - Is the person responsible for solving the exercises, using the developed system. He is considered a user with restrictions Administrator - Is the user with more system privileges. The administrator can make any desire change. ForgeBox e-larning - A set of contents in the form of text or interactive format made up by blocks consisting of a series. Module - is a grouping of visual content that can be divided into two types: Interactive module - the group formed by elements (ssh, switches, etc.) that specify the part of the practice of this tool. Presentation module It refers to the theoretical content of our course. Program - unit set of instructions that allow a computer to perform various functions. Compiler - A program that converts the programming language used by the user into the programming language used by the computer The main element of our project is the creation of the e-learning course by using the FORGE tool. We will take advantage of this tool by using it as a platform because its graphical environment is simple and easy to understand for students. This is the life cycle of the creation of our project: 1. Development of an e-learning course by the teacher or creator. 2. Add the course to the system database. 3. Check the proper functioning of our course. If the behavior is not as desired, return to step 1. 28/100

29 4. Publication of the course. 5. Resolution of the course by the student. 6. Assessment of the exercise by the teacher or creator. FORGE is a great tool because it presents how it plans to use the FORGEBox solution and services.a FORGEBox might be hosted by an organization offering certain courses to its learners, installed in organizations datacentre or dedicated nodes. It can also be hosted by organizations (like the OU) that want to provide access to a larger community of learners. Finally, a cloud deployment will be also possible, supporting learning communities in larger scale. When having FORGEBox installed under a certain domain (e.g. myforgebox.example.org) the Lab Courses can have a target to reference for locating content. Figure 2: FORGE plans. Specifying educational objectives Educational objectives or learning outcomes cover knowledge, skills and personal, social and/or methodological abilities that a learner should have acquired when successfully having finished a learning opportunity. According to the European Qualification Framework (EQF), learning outcomes are defined in terms of knowledge, skills, and competences. Knowledge is the outcome of the assimilation of information through learning. Knowledge is the body of facts, principles, theories and practices that is related to a field of work or study. An example 29/100

30 learning outcome about knowledge would be: Students are able to enumerate and explain the seven layers of the ISO/OSI Reference Model. Skills are the ability to apply knowledge and use know-how to complete tasks and solve problems. An example learning outcome about skills is: Students are able to design an interactive website that complies with Web Accessibility Guidelines. In this example, in order to achieve this skill, students will need to assimilate knowledge in web programming and web accessibility. They will be able to do something by applying knowledge, therefore this signifies a skill. Competence is the proven ability to use knowledge and skills in work or study situations and in professional and personal development. One key aspect of a competence is the degree of autonomy and responsibility with which students are able to apply knowledge and skills. An example of such a learning outcome would be: Students are able to review the architectural model of a given system and formulate suggestions for improvement based on relevant software metrics with minimal supervision by a tutor. This learning outcome requires the ability to use knowledge and skills: it requires knowledge about architectural models and software metrics; it requires the skills of being able to do a critical review, apply software metrics, and suggest improvements to the model. It is a competence because it adds information about the degree of autonomy by stating that students are able to do this with minimal supervision by a tutor. 4.2 ForgeBox managing services. A FORGEBox instantiation will contain a set of management services. A web control panel will be the mechanism to access and configure those services. Through these management services, FORGEBox admins will be able to perform the following tasks: - User management. Create and manage accounts for users that are Lab course assistants, or simple users that want to use FORGE technology - Manage FORGEBox services that can be exposed and used by other users. - Configure repository access. The admin can configure access points (i.e. URLs) that point to other FORGE repositories or even update and configure repositories content - FORGEBox updates. The admin can perform updates to any core services of FORGEBox. Widgets layer Widgets usually provide interactive web content to learners. This means that access should be provided by web containers and web services. Therefore the widget layer will not be a specific service, but rather an abstract concept, since widgets can be provided by several web containers. As web containers can be consider for example the Apache server or Tomcat. However, we expect that a local repository will keep track of the deployed widgets. Fire adapters layer 30/100

31 As widgets layer is a concept, the same also holds for the FIRE adapters layer. FIRE adapters can be developed in any language or hosted by some kind of container. Still, a local repository needs to be in place, to keep track of what is deployed and what can be exposed as a FIRE adapter service Synergies widgets adapters Synergies between FORGE widgets, adapters and FIRE resources When a lab course is executed by a learner, either via a LMS web page or an ibook there are some underlying interactions that happen between different components. Especially between widgets, adapters and the course related FIRE resources. Widgets, as envisioned by FORGE, are going to be the main element towards the Learner for accessing and manipulating some FIRE resource parameters through web pages, LMSs and ibooks. Figure 3: FORGE management services. The Figure provides a detailed view of FORGEBox proposed architecture. The figure displays also the concept of a FORGE repository that will host any shared published items such as Lab Courses, widgets and FIRE adapters to be used by the learning community and by other organizations hosting a FORGEBox instantiation. At its simplest form the core consists of services that make some tasks easier such as creating, managing and operating Lab Courses and their content as well as widgets and 31/100

32 adapters. FORGEBox will contain a set of managing services, a Widgets layer, a FIRE adapters layer and a local repository of hosted Lab Courses. 4.3 Specification of software requirements Functional requirements As previously mentioned, a function requirement defines the internal behaviour of the software. The functional requirements of the system should be the following (the use cases will be described later on):, To develop a course, the course designer must identify and/or define several context components that will affect the course development and deployment since the most suitable FIRE facility and FORGE tools will be adopted based on these components. The most relevant components are: Dates: The dates when the course will be performed. It may affect the selection of FIRE facility due to scheduling and booking matters. Number of students: The amount of students who will perform the course directly maps into the amount of equipment and the sharing/scheduling mechanisms to be applied in the FIRE facility. Geolocation and connectivity: An important factor to know in advance is the location in the world and the type of connectivity available. Depending on such information, different facilities may be chosen. Computational devices to be used (ibook, ebook reader, laptop/pc,tablet): Regarding the main devices to be used by the learners, different FORGE tools may be applied. LMS to be used: Same as the previous item, the Learning Management System (LMS) capabilities will determine the FORGE tools to be used. Language: The language to be used for the content development. Moreover, the language to offer support by FORGE will be, mainly, English with exception of the mother tongues of our partners, if they are available for such task. Financial matters: Regarding the financial model of the course, different FIRE facilities services can be provided/offered, since some of them offer differentiated services depending on the level of service previously agreed. 32/100

33 4.3.2 Non- functional requirements Non-functional requirements are those characteristics of the system that do not provide new functionalities but are rather constraints of the system when adapting to the needs of the product. The nonfunctional requirements presented by the application are listed below: The course with the FORGE system must allow programs to be run safely without compromising the information found on the server. The course with FORGE system should be multiplatform and should work on any operating system using any of the two browsers for which it has been optimized (Google Chrome and Mozilla Firefox), although it is expected to work with other browsers such as Safari. The system should be intuitive so the user will need very little time to adjust to the way it works. The system must provide the ability to manage a large numbers of users User Cases Use cases describe the sequence of interactions that take place in the FORGE tool, as well as the participants involved in the process. Users Teacher Administrator Student Figure 4: Scheme of the tool participants 33/100

34 User The first steps of the user who is beginning to use the FORGE platform are as follows: You can use FORGEBox in many different ways, ranging from embedding Jetty in applications, launching it from different build systems, from different JVM-based languages, or as a standalone distribution. This guide covers the latter, a standalone distribution suitable for deploying web applications. - Log on to the FORGE platform: it allows the user to access the application (teacher and student). You can register as shown in the figure or access via your Gmail or GRNET if you have the appropriate credentials. Figure 5: Login to the FORGE tool. - Log out: allows the user to log off the system. -List of courses: displays the list of courses that the user can access, accomplish, perform autotests with different exercises and solve problems, conduct tests after finishing them... These courses are divided into different sections so you can choose the topic that interests you. Networks, Wireless, General, IEEE standards, TCP / IP, Congestion Control, Performance Evaluation. 34/100

35 - Open course or download: allows the user to open a course or download it in epub and to use the course in another e-learning platform. Figure 6: Courses available in forgebox - Save course: allows the user to save a course resolved at a session. Designer/Assistant Teacher/ Teacher The methodology for creating FIRE courseware that has been developed in FORGE, guides the course designer from defining the course up to deploying it, considering the educational and technological requirements, which are part of the adopted LD approach. The methodology describes the steps that have to be taken in order to create and/or reuse a course within the FORGE context. These steps, describing two main stages: - The course preparation, where the course designer must identify the requirements for the course. - The FORGE supported activities, where depending on the identified components in stage a, different components will be set. 35/100

36 Figure 7: Scheme of supported activities and course preparation. The next step for developing our course is: Identifying FIRE facilities. In this step, the course designer needs to identify the FIRE facility which best suits the requirements of the course one wants to develop. There are various aspects which come into play. The two most relevant ones are related to: - Facility features and reservation practicalities. The first and most important task is to identify the facility features which match the intended course content. When someone, for example, wants to include experimental exercises using specially developed wireless transmission protocols, a facility should be chosen where one has permission to 36/100

37 adapt the radio drivers or where one can use cognitive radio devices, etc. A basic overview of the most prominent facility features covered in Fed4FIRE. - Forge widgets and adapters Now that the course requirements have been specified and an appropriate FIRE facility has been identified, the course designer needs to determine what widgets (the interface with the experiment) and adapters (theinterface with the facility) to use. A widget is a service that runs in a remote environment and can be accessed through a web interface. Adapters are small programs or scripts which aid in the conversion of requests from widgets (controlled at client side by learners) to actual calls for starting, stopping or controlling experiments at a FIRE facility. The FORGE project has organized and categorized all its components and content in such a way that all interested parties can search, locate and reuse existing software, resources and educational content without the need of creating everything from scratch. The following paragraphs describe how these concepts are implemented in FORGE technologies. Before describing the process of creating a complete educational course we need to give a small description of the two major platforms, FORGEStore and FORGEBox. - FORGEStore: FORGEStore is an online marketplace which contains the complete set of sharedwidgets, FORGEBox services, FIRE adapters and shared interactive courses.forgestore items are developed by the FORGE team members as well as severalthird party organizations that are interested to share learning material forfire experimentation. - FORGEBox: FORGEBox is a platform that interconnects learning interactive content withfire resources rather than an LMS. It is the place where a course designer hasaccess to all the necessary utilities to create a lab course. An organizationcan setup its own FORGEBox platform and design its own educational content. Alltools required to create a course (e.g. widgets, adapters etc.) can be importedin a FORGEBox installation, directly from FORGEStore. Both FORGEBox and FORGEStore platforms require from an enduser to be registered and signed in. - Identifying/using/reusing existing FORGE widgets, courses and adapters 37/100

38 FORGE offers a large variety of tools and content that has been designed by multiple organizations across Europe. All interested parties are recommended to check the FORGEStore market place for any apps, widgets, adapters or even complete courses that they can download and use for their needs, before they start creating their own courses. - Working with existing widgets. These widgets are organized in different categories based on their functionality and capabilities. Examples of these categories are: future internet, monitoring, networking, course support etc.each widget has a "View Details" button where more information aboutthe widget is presented. If a user wants to use an existing widget they cannot download it directly from FORGEStore, but instead, the process of installing a widget is an automated process performed through the FORGEBox platform. All FORGEBox installations are connected to the widget repository of the FORGEStore marketplace by default. If a user wants to download a FORGE widget from the FORGEStore market they must use the option Widgets > Install New (header menu) in their FORGEBox account. They will be redirected to a webpage with a dropdown menu where they can select the repository from which they wish to locate the desired widget. (Yes, FORGE allows multiple widget designers and providers to create and host their own widgets). By selecting the option FORGEStore, the user can see the list of available widgets from the FORGEStore market place, identify the widget they want and download and install it in their account. Working with existing Course Bundles. A user can see the list of available FORGE courses in FORGEStore by selecting the link "Course Bundles" from the top (header) menu. A FORGE course Bundle is a complete package of an educational course, in SCORM format, which can be imported in LMS system to be used forteaching purposes. FORGEBox installation forfurther editing or modifications. With course bundles FORGE gives the ability to its users to share and use off-the-shelf educational material that can be immediately imported across multiple platforms and learning systems. Working with existing Services/FIRE adapters. A user can see the list of available FORGE adapters in FORGEStore by selecting (from the headermenu) the option "Services/FIRE adapters". Like widgets, each service/adapter also has a "View Details" button. By clicking this button, a user can see more information about this service/adapter. 38/100

39 FIRE Adapters are backend services, for which, FORGEStore gives instructions on how to either install this FIRE Adapter or use it as a web service. In many cases they are just packages that lab course designers can download and install into their FORGEBox installation. -Developing your own widgets/adapters and sharing them with FORGE The philosophy behind the FORGE architecture is to allow the creation of diverse widgets/adapters that can perform different tasks and meet diverse needs and requirements. The whole process of creating new widgets/adapters is intentionally designed to be open and very flexible since they are offered as web services available to be used in course mashups. There are no specific guidelines on how to create a widget but only instructions on how to embed your remote service (widget/adapter) inside a course or system and link it with the resources that are used to operate it. Figure 8: Adding a new widget in FORGEStore - Widgets and thelearning Tools Interoperability LTI standard Widget developers are encouraged to follow the LTI standard for their developments. This will allow the seamless integration of widgets inside any Learning Management Systems and will allow the identification of a learner s identity, which can later be used for monitoring their behaviour using APIs like the TinCAN API. FORGE widgets are towards investigating the adoption of LTI ready to be consumed be LTI compliant LMSs. 39/100

40 - Educational content The educational content that can be placed in a FORGE course is any kind of learning material that can help a teacher achieve the course s learning targets. This material can have the form of text that describes the theory behind a specific exercise, questionnaires with multiple-choice options, videos with lectures, videos with instructions on how to conduct the exercise, images and diagrams about the architecture and topology of the required components, graphical representations of the desired results etc. A teacher can also create links and references to online books and other exercises or even upload their own documents e.g. slides. The only requirement for using a specific piece of learning material in a FORGE course is its ability to be integrated and presented in the FORGEBox platform and later on ready to be consumed by any modern LMS. This means it has to be available in some kind of a web format. We advise lab course designers to include some information about the FORGE platform and FIRE facilities in their educational content. This would give students an idea about their exercises underlying platform and will also help them with the use of widgets and adapters. - Integration of widgets/adapters/content The content of a course, the widgets and the back end FIRE Adapter services are integrated to provide a full experience of an interactive course. Next sections present how these elements are integrated together into the FORGEBox platform. - Create the FORGE educational package When a user creates a new account in FORGEBox he is able to view and perform FORGEBox courses (with the learner role) but he cannot create a course. In order to be able to create educational content, a user must contact the administrator of the FORGEBox system and upgrade his account to lab designer. - My course modules When users log into the FORGEBox system they are able to view courses that have already been created by other users. To create their own course, the user must follow the link Courses> My Course Modules from the top menu. They will then be redirected to the webpage My Course Modules where all the required tools for creating and managing their own courses are available. In the My Course Modules page the user has three options; to create: 40/100

41 -new CourseModule -new Course Presentation Part -new Course Interactive Part. New Course Module: With this process the user can create a new lab course. For the creation of a course module a user can use one or more course presentation parts and one or more course interactive parts. New Course Presentation Part: This process does NOT create a new lab course. It creates a part (or section) with theoretical information about the course (text, pictures, videos etc.) that can be inserted in one or more course modules. New Course Interactive Part: This process does NOT create a new lab course. It creates a part (or section) with the tools (widgets, adapters) required to conduct the exercise. It can also be inserted in one or more course modules. - Creating a New Course Presentation Part In a course presentation part a lab course designer can insert theoretical information about the course (text, pictures, videos etc.) but not any tools or software for conducting the exercise. By selecting the New Course Presentation Part the user will be redirected to a new webpage, where the following form is available: 41/100

42 Figure 9: New course presentation part form In this form the user must complete all requested fields (e.g. Title, Small Description, Language etc.). In the Course Content field the user can insert all the theoretical information about the course (text, videos, pictures etc.). The toolset above the Course Content field offers a large set of capabilities (e.g. style your input, import links, edit html code, import/upload videos and pictures etc.). Once the user completes all the fields and content, they can click the button at the bottom of the page and Create the part. The new Course Presentation Part can now be found in the (header menu) Courses >Course Presentation Parts page. - Creating a New Course Interactive Part. In a course interactive part a lab course designer can insert the tools (widgets, adapters) that are required to conduct the exercise. By selecting the New Course Interactive Part the user will be redirected to a new webpage where they will find a similar form like the one in the presentation part. However, there are three additional fields in this form that allow a lab designer to insert and manage tools (e.g. widgets) that are required for the course. These fields are the Interactive Category, the Interactive Item and the URL. 42/100

43 Figure 10: New course interactive part form In the Course Content the user can insert information (text, pictures etc.) about the use of the course's tools. When all necessary fields and content are completed, the part is created by clicking on the button at the bottom of the page. The new Course Interactive Part can now be found in the (using the top menu) Courses > Course Interactive Parts page. -Creating a New Course Module. Using the new Course Module option, the user can create and publish the actual Lab Course. By selecting the New Course Module they will be redirected to a webpage in order to fill in a form with the Title of the course, a Small Description etc. In the Course Content the user can insert general information about the course or they can leave it empty and add a Course Presentation Part with information about the course. Once all the required fields are filled, the "Create your new Course Module" button at the bottom of the page creates the course. If everything has been done properly, the New Course Module should appear in the Courses > My Courses webpage. All Course entities are LRMI compliant: All above mentioned artefacts (Presentation Parts, Interactive Parts, Course modules) also have a list of entry fields that course designers can fill in order to make their course exposed as Learning Resource Metadata Initiative (LRMI) metadata. With this option I have accomplished the learning course on the implementation of a server-client. I have used in this course interactive and presentation parts but this will be described below. 43/100

44 - Identifying/using/reusing already existing educational content Similar to widgets and adapters, it is recommended that all interested parties should check FORGEBoxand FORGEStore for any available educational material that is suitable for their needs, before starting to create their own courses. This material can be one of the following. 1 Complete lab courses which be found in: a. FORGEBox in the form of course modules created by users of the same FORGEBox instantiation, b. FORGEStore marketplace in the form of complete packages (e.g. scorm) ready to be installed in a FORGEBox instantiation or an LMS. 2 Presentation Parts and Interactive Parts that have already been created in the FORGEBox instantiation. - Integrating existing educational content - Adding Presentation and Interactive Parts The course designer can add one or more Presentation or Interactive parts to a Course Module. In order to do that, the user must click on the Parts icon and then select from his Presentation and Interactive Parts the items they wish to include in the Course Module. Figure 11: Adding parts in the course module 44/100

45 - Export educational content for reuse FORGE courses can be exported from FORGEBOX and reused in an LMS or FORGEStore as.epub and SCORM formats. In the list of courses (Courses > My Courses) the user must click the edit option for the course module they wants to export and share. They will then be redirected to the editing page of this course. At the bottom of this page there is a section called Generate files (epub, SCORM) with two buttons that automatically generate the epub and scorm files of the course module. Figure 12: Create SCORM/epub files Once the user clicks these buttons and returns back to their course modules list (Courses> My Courses) they will see that the export files for the specific course module have been created and are available for download. Figure 13: Download SCORM/epub files 45/100

46 - Deployment With everything in place, a course is ready to be deployed and used by FIRElearners. Two issues must be noted before deploying: 1. deploy the educational content and notify learners of the webpage about the course 2. reserve and activate the appropriatefire resources (e.g. hosts, network components etc.) required for the specific course. The deployment of the educational content in an LMS depends on LMS capabilities. We encourage the use of SCORM import functionality if present in your LMS by referring to the appropriate package in FORGEStore. The process of activating the appropriate FIRE resources may vary depending of the FIREfacility chosen to run the course. Usually Fed4FIRE tools (like jfed) should be used by lab course assistants given that they already have a Fed4FIRE account. - The idea of FIRE lab course setup recipes: -teachers companion FORGE developed the idea of having ready services that can easily setup the underlying lab for a course. These services are more or less ready setup recipes used by teachers to quickly and easily schedule and setup the experiment on behalf of multiple learners. Web service developed by the University of Patras (UoP) that gives the opportunity to easily set up the Congestion Control course over the iminds Virtual Wall testbed without the need to download and install specialized tools designed for the iminds Virtual wall. The necessary artefacts are: the user s identity from FIRE (Fed4FIRE account injfed), the number of nodes to be reserved and the desired schedule. 46/100

47 Figure 14: Activate the testbed Another example of such a lab set up recipe is used to reserve nodes at the iminds w-ilab.t testbed. Some facilities, such as the iminds w-ilab.t, may have mandatory reservation mechanisms in place, due to recurring node scarcity. When deploying a course one must also evaluate the need for an always-on instance for remote learning. Depending on the facility used and the scarcity of the available resources, this can be as simple as performing the necessary steps required for a lab execution, but leaving the resources running indefinitely, or a more complex deployment strategy needs to be worked out to allow on demand deployment and execution. - Evaluation. The evaluation of the courseware is performed with the following methods: 1 Learning Analytics (Quantitative instruments) 2 Interviews and questionnaires (Qualitative instruments) FORGE offers educators an evaluation framework, which constitutes a variety of ways to collect feedback data on the execution of courses, via both qualitative and quantitative instruments. The qualitative instruments consist of a set of questionnaire templates targeting two distinct groups of stakeholders, teachers and students, and collecting feedback about the quality, the reusability, the ease of use and learning effectiveness of the learning materials. Indicative questionnaires are annexed to the 47/100

48 present project. The quantitative instruments are based on Learning Analytics tools for monitoring the activities of learners. In particular, FORGE will offer the software libraries for enabling educational widgets to collect usage data, as well as the methodologies for analysing them with Learning Analytics tools. Reflection and adaptation By analysing the qualitative and quantitative data collected from the evaluation of the course ware, educators have the opportunity to reflect and draw some conclusions about potential adaptations to the courseware. In particular, visualising the Learning Analytics data with the help of a Learning RecordStore (LRS), such as the Learning Locker, can help educators identify patterns in the usage of the course ware and detect potential weaknesses in the design of their courses so that they can further improve them. They are also able to identify learners who may require extra support and attention. Additionally, educators can offer Learning Analytics services to learners to enable them to reflect on their achievements and patterns of behaviour in relation to their peers. Qualitative data from questionnaires and interviews can also help in identifying potential weaknesses in the courseware, especially from open-ended questions recording the learners experiences with the courseware. - Aligning the FORGEBOX technology and existing educational solution. FORGEBox is a technological prototype solution that integrates all the necessary artefacts to create FIRE interactive courses. It is based on open source software and its responsibilities are to: Integrate and host widgets, FIRE Adapters and interactive courses ease the way for lab course creators to build courses that involve FIRE interactive course material (widgets, adapters, content) integrate and host FIRE course recipes and the underlying services that prepare a course setup on FIRE facilities. Although it offers simple learner access for just a simple and open access solution, it is not and cannot be an LMS replacement. Instead the provided material created with FORGEBox is ready to be consumed by advanced elearning systems through integrated FORGEBox mechanisms that export the content in other well-known formats, like SCORM. This is depicted in next figure, where FORGEBox is used to build a course module and later on either use it as it in from an LMS (i.e.through standard iframe or LTI) or export it to other formats. 48/100

49 Figure 15. Creating a course in FORGEBox 49/100

50 5 Design of the solution The behavior of the web tool used has been described in detail because it is a major part of our project and important for the implementation and design of our module. Now we shall provide details on the implementation and the technologies to be used for developing our course. This design phase is very important because it is the creative part in which the designer defines how the application is developed in terms of implementation. One should keep in mind that when creating a course, design and implementation are two completely different terms, so in the design of our course we shall explain what must be implemented, but not how it should be developed. This chapter will explain the design of our course. First the application model is explained, that is the type of application one desires, in this case a client-server application. Second, the data and conceptual model will be detailed indicating the type of software to be used and its correct implementation. Thirdly, the aspects of the user interface will be indicated. The compilation and execution model will be included in the next part, since this is an application that allows execution of programs created by users. And finally, the steps to be followed by the student for accomplishing our course will be described. 5.1 Client- server model This project is based on a client-server architecture using socket programing. The client-server architecture, as defined in the Wikipedia: "It is a distributed application model in which tasks are distributed among the suppliers of resources or services, called servers, and the petitioners, called clients. A customer requests to another program, the server, who gives an answer. This idea can also be applied to programs running on a single computer, although it is more advantageous in a multiuser operating system distributed across a network of computers. ". In this case, for course implementation, as mentioned earlier, we will use the FORGE tool as a platform for e-learning, the iminds virtual wall test bank that runs through java, the user identity FIRE (Fed4FIRE account jfed) and the UoP proxy server that is provided by the University of Patras. These technologies will be described in detail later. The distributed system created this way, among other things, allows end users to access information transparently regardless of the platform. In our client-server architecture we need a central process that meets the users' requests and subsequently builds a response to the request made. We can see in this simplified scheme the performance of the client- server. 50/100

51 Server Client Start Conection FORGE/ UoP proxy/ vwall Conection with sockets Figure 16: Performance client-server The main elements of the development of the server are: 5.2 Creation of server The functions of our server are: Make opening a socket, using function :socket (). This function returns a normal file descriptor, as can return open (). Function: Socket () does absolutely nothing, except restore and prepare a file descriptor that the system subsequently associates a network connection. Notify the operating system that we have opened a socket and we want our program to associate that socket. This is accomplished by bind the () function. The system does not yet serve client connections, 51/100

52 merely it notes that if you begin to do so, you must report it. It is in this call when you should indicate the number of service you want to attend. Notify the system start serving that network connection. It is achieved by the listen () function. From this point the operating system will note any client connecting when we ask. If they come faster than we are able to attend the clients, the operating system makes a "tail" them and us going as we go asking for it. Ask for and accept client connections to the operating system. To do this we make a call to accept () function. Close communication and socket, through the close () function, which is the same used to close a file. -A server and client flow: a. Creating a TCP socket using the call to the socket () system. b. Assigning a port number to the socket by calling bind (). c. Tell the system that allows the port connections mentioned earlier, this will be done with listen(). d. And repeatedly do the following: - Calling accept () to get a new socket for each connection made by the client. - Communicate with client via the new socket using send (). - Close the connection when you stop using it. We make the process description done on the server: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> 52/100

53 // The port users will be connecting to #define PORT 5600 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error lol!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = INADDR_ANY; //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &s_op, sizeof(s_op)) == -1) { perror("setsockopt"); exit(1); 53/100

54 //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request //which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client 54/100

55 if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); return 0; Problems. Multi- servers In our learning course the student has to address several problems associated to the use of multiservers. For this purpose we create 3 files: Server1.c : In this file the student has to identify the error produced in the instruction of the port: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT 5400 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2; struct sockaddr_in server; //my address information of server 55/100

56 struct sockaddr_in client; int sn_size; //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error lol!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = INADDR_ANY; //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); 56/100

57 while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); return 0; The port of the server should be the same as the port of our client in order to establish the connection between them. 57/100

58 Server Port Port Connection Port Client Server Port Client Connection request Figure 17: Connection/ Connection request client-server. 58/100

59 The second problem that arises in file server2.c: The client will try to establish a connection with an IP address, obtained by executing the command ifconfig in the server terminal, but will encounter an error in the reception of the bind() in client. The problem is: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT 5600 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2; int s_op = 1; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; 59/100

60 //Automatically fill with server IP server.sin_addr.s_addr = inet_addr(" "); //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &s_op, sizeof(s_op)) == -1) { perror("setsockopt"); exit(1); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); 60/100

61 else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); In the instruction : server.sin_addr.s_addr = inet_addr(" "); We establish a specific IP. This means that if the client tries to connect with the IP of our server or with any other IP different to the one specified, access will be denied. It can only access the server with the address IP: In order to solve this problem, the student must modify the specific IP by the instruction INADDR_ANY; this will provide an automatic fill with server IP. The third problem in the file server3.c: We shall add an int fd3 () file to our main method: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> 61/100

62 // The port users will be connecting to #define PORT 5600 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2,fd3; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error lol!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = INADDR_ANY; //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); 62/100

63 else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd3, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); return 0; 63/100

64 By using the fd3 file, we encounter an error in our listen() function since this file is empty and does not contain any type of information. 5.3 Creation of the client The steps you need to follow a client program are: Open a socket, and the server, through the function socket (). Order connection to the server through the connect () function. This function is blocked until the server accepts our connection or if there is no server in the right place, it will give an error. In this call you must provide the IP address of the server and the service number you want. Write and receive data from the server via the functions write () and read (). Close communication through close (). As you can see, the process on the client is much simpler than the server The client will connect to our server flows: The typical TCP client in its communication involves four basic steps: a. Create a TCP socket using the call to socket () system. b. Establish a connection to the server using connect (). c. Communicate using send and recv (). d. Close the connection with close (). We make the process done on the client: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <netdb.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT /100

65 //The max number of bytes that we can get at once #define MAXDATASIZE 1500 int main (int argc, char *argv[]) { int fd,numbytes; char buf[maxdatasize]; struct hostent *he; struct sockaddr_in server; //if no command line argument supplied if (argc!=2) { printf("client-usage: %s the_client_hostname\n", argv[0]); exit(-1); //get the host information if ((he=gethostbyname(argv[1]))==null) { printf("gethosbyname() error\n"); exit(-1); if ((fd=socket(af_inet, SOCK_STREAM, 0))==-1) { printf("socket() error\n"); exit(-1); else printf("client-the socket () is OK...\n\n"); //host byte order server.sin_family = AF_INET; //short network byte order server.sin_port = htons(port); server.sin_addr = *((struct in_addr *)he->h_addr); //zero for the rest of the struct bzero(&(server.sin_zero),8); if (connect(fd, (struct sockaddr *)&server, sizeof(struct sockaddr))==-1) { 65/100

66 else printf("connect() error\n"); exit(-1); printf("client-the connect() is OK...\n\n"); if ((numbytes=recv(fd,buf,maxdatasize,0))==-1) { printf("recv() error \n"); exit(-1); else printf("client-the recv() is OK...\n"); buf[numbytes]=0; printf("client- Received: %s\n",buf); close(fd); printf("client- Close() is OK! \n\n"); return 0; Our e-learning course will be focused only on problems that arise with multiservers. The file client.c should be implemented and executed but we shall place emphasis on the server. In the FORGE platform we can find a course focused on sockets programming multing client that is still under construction. 66/100

67 5.4 Interface design Taking into account the potential users of FORGE, whoever they may be, the user interface, which is what the end user actually sees, is of great importance since it is the only way the user can communicate with the system. This section explains what the user graphic interphase is in our course. First, remember that this is an e-learning course based on a client-server approach. Below we include a scheme representing the final aspect of our course. We talked earlier about the FORGE platform used and how to create and use different modules, aimed at our training course: Our course includes: A new Course Module which is composed of: Two courses with a presentation part and two courses with an interactive part. Figure 17: Course Module 67/100

68 5.4.1 First curse. Presentation part. In the first year of the introduction part there is a brief introduction and explanation of socket programing. With this information the user has to deal with the exercises and execute them successfully. Figure 18: Interface Presentation part Second module. Interactive course. Composed of the following elements: Title: Connect server. Small description: Multiserver - Exercises to learn the use of sockets and to solve the exercises. Interactive category: Interactive Widget. It is necessary to activate the widget, we shall deal widely about this in section 4. 68/100

69 Figure19: Connection of the server Interactive Item: ssh2web. URL: We will use the link with the appropriate credentials to enable connection to our remote server. Later in the part of technologies used we shall discuss how we proceeded to implement it. Course content: We will write the instructions that we want the student or person performing the module to follow. The guidelines to follow are: - Compile serverx.c: To compile the file the student must execute the command: Figure 20: Commands virtual machine. cd /local/servers cd servers gcc -g server1.c -o server1 69/100

70 ./server1 With these instructions, the student can compile and run the different files. (Server1.c, server2.c and server3.c). - Check connectivity. When checking the connectivity, we should start the terminal where we shall compile and execute the client. We discuss these steps below. - Edit serverx.c (e.g. using vim). Once the student has proceeded with the compilation and connectivity, an error message will appear. It is then when the student has to try to solve the problem that may occur in real life. The student must edit the server1.c file with the command: vi server1.c This command allows the student to visualize the file code, identify the error and correct it - Save and recompile. Once the error is identified, it is solved and saved with the command: :wq After this, we newly proceed to its implementation and execution. - Check connectivity. Once all the previous steps have been executed, we verify that the problem posed has been resolved. We check the connectivity between the server and client. We execute the command again:./server1 70/100

71 We shall use another interactive part course for accomplishing the same steps as in the previous interactive part but this time it will be oriented to the client, because we can only include one forgebox per each of the interactive parts. In our whole course module we shall need one forgebox for the server and another forgebox for the client Third module. Interactive course. - Title: Connect client. - Small description: C - Interactive category: Interactive Widget. In this part it is necessary to activate the necessary widgets. - Interactive Item: ssh2web. - URL: We will use the link with the appropriate credentials to enable connection to our remote server. - Course content: We will write the instructions that we want the student or person performing our module to follow: Figure 21: Connection of the client. 71/100

72 - Compile client.c: To compile the file the student must execute the instruction: Figure 22: Commands virtual machine. cd/local/servers cd servers gcc -g client.c -o client./client - Check connectivity. To check client connectivity, you must first know the IP address to be connected, and as shown in the figure above, we must specify the IP address used. This in the server terminal we shall execute the command: ifconfig By using this command, we will be provided with all the server information: 72/100

73 Figure 23: Information IP server. Now the student is ready to proceed with the connection. As shown in the previous figure, we will use the IP address: We compile and execute client:./client xxx.xxx.x.x à corresponds to the IP of the server in each of the cases of connection. (client ip address, client port number) Client Server (server ip address, server port number) 73/100

74 5.4.4 Fourth module. Course presentation part In the last part of our course module we shall use the presentation part: We shall add boxes so that students can insert their answers to the different problems encountered with the various servers. In this part of the presentation, we will include HTML code as shown in the figure and the students can insert the answers to the proposed problems and save them in their FORGE session. Figure 24: Html code The graphic design of our HTML code: Figure 25: graphic design. 74/100

75 5.5 Compilation and execution model through remote servers. The primary goal is focused on providing the user the ability to connect to a client-server implemented and corrected/ by the user himself, but with the difference that the user can run parts of the code that have not been written yet. Being a client-server system it is possible to run the code on the client side or on the server side. The option selected is explained below and it is justified taking into account the problems encountered and the need to choose the one that fits best the requirements of FORGE. Running a program on the client side or the server side means that the program implemented will have to be supported by the resources available to our FORGE tool. To provide the desired interaction with the user and given the possibility that the user can run and compile the code created from his computer, in this scheme we can clearly see the procedures followed: Figure 26: Schema of system. 75/100

76 The use of this technology in our project will allow us to: - Study and Develop new Processes and Approaches to online learning based on the integration of FIRE facilities and elearning technologies. - Inject the FIRE portfolio of facilities and tools into the higher education learning sphere. - Introduce the learning community to the concepts of Experimentally Driven Research. - Increase the overall accessibility and usability of FIRE facilities through the layering of how-to-use resources over the FIRE platforms. As we can see in the figure above, for the execution and compiling through remote servers we use the jfed application Creating our jfed scenario. To create our server-client scenario, we will open the jfed application. For this application it is necessary to have previously installed the JAVA program. The system first requests a certificate and a password: Figure 27: Jfed login. 76/100

77 We obtain the certificate through We register and justify the project we will accomplish by using this tool. We find a tool that provides jfed called: RSpec editor. Previously, we have created a.rspec file. The creation of this file will be discussed in the next section of this document. - We start by loading the default topology in jfed. - We start jfed for this file. - In the jfed experiment kit Tool menu, select the Add file button.rspec. - We created our virtual scenario: Figure 28: Jfed experiment Toolkit Our scenario will include: - Five servers. - Five customers. For the development of our e-learning course we do not need to reserve many of the servers provided by jfed. Therefore with five client- servers, we are ready to develop our course. 77/100

78 Once we have defined our scenario, we will press the button Run. The following message will appear: Figure 29: Start an experiment run To start an experiment run you must specify: - Name: The name you use in your scenario. - Project: the license provided by the certificate to use remote servers. - The most important part: We must specify how long we want to reserve the provided servers. Therefore we should not use them for too long since we are using remote resources that are shared with other users. Once all the steps are completed, users can accomplish our e-learning course RSpec file creation. As mentioned earlier, this file has an important role in the development of our project. A file. Rspec provides a specific domain of the language -DSL - for a specific object behaviour. With this file we intend to describe the behaviour of our scenario. The.rspec file will use the ssh-key (id_pub) specified in preferences. With this private keyword one can access restricted resources. It is also possible to use a public ssh keyword extracted from your pem certificate. 78/100

79 Normally, tool jfed tool will hide these RSpecs. They will only be visible to the creator of the virtual scenario. In the.rspec file we shall add the code of the files: server.c, client.c, server1.c, server2.c and server3.c. When the user or student starts our course and proceeds to reserve these remote servers, the files required for server-client connections will be available. In the annex the file.rspec created for this project is attached. 79/100

80 6 Technologies applied. The technology used for the project. There is a similarity between the creation of our course and an iceberg: in both cases the non-visible part is considerably larger. The same applies in this application where the visible part corresponds to the user interface, yet this only covers a small part of all the technologies used and the work done, as shown in the figure below. This analogy represents the project as an iceberg, where a small visible part is the final interface with which the user interacts and below, there are multiple technologies that make the accomplishment of our course feasible. Figure 30: Technology used 80/100

81 7 Conclusion and future work 7.1 Conclusion In this final project, a training course on the introduction to programming aimed at beginning students has been developed and implemented. Thus an e-learing client-server course denominated SOCKET PROGRAMMING IN C - SERVER SIDE, is presented This e-learning course, among other features, has a simple and friendly interface available by using the FORGE tool. Students can easily adapt to it, in order to focus more on solving the exercises than in learning how to use the programming environment. When a student begins to get immersed in the world of sockets, by using this system, exercises are available where the statements are integrated with the practical parts, ie, with sections where you can write the code. This helps the student to focus on a programming problem or challenge, thereby strengthening the knowledge acquired in the theoretical part of the course. Moreover, the tool allows students to run the programs they have elaborated, interacting with these programs through a remote terminal and also allowing the possibility to activate code written by themselves or by the teacher, depending on the needs, and check for proper operation. Alternating between the student code and a default code allows students to run the program by typing only parts of it, as the rest of the code will be written by the teacher or creator, thus facilitating the correction of certain parts of the code. Finally, the course through FORGE has been implemented and designed for ease of use from several different web browsers and operating systems so that students can use it comfortably without installing any application on their computer. This gives great flexibility to develop courses and examinations or complementary exercises that can be added and perform at home by the students. Besides completing the e-learning course by the student, the tool has also been developed to give special consideration to the development of practical work by the teacher. That is, a teacher can make more conventional practices (exercises that consist of a statement and a piece of code that runs directly) using standard templates and modifying the content. But our course is flexible enough for the teacher to be able to modify these scripts and perform more complex exercises. For example, drawing elements on screen, re-implemented functions in a statement in different programs, generate test cases, etc... In terms of development, the implementation of this project has been very rewarding and challenging. Previously I had no knowledge of the tools that have been applied. This has made me familiar with innovative technologies related to the world of e-learning which nowadays are very demanded in professional environments. 81/100

82 7.2 Future work The current project has been accomplished bearing in mind the generation of an e-learning course for the user by means of the FORGE tool. Some of the improvements and additions that are possible have not been included due to the scope of this assignment. The following are some of the features that can enhance or complete the course with a tool still under development. In our case we have used FORGE as an e-learning platform although we know that this is not the original aim of this tool. Thus some of the features that could be added would also involve implementation in FORGE. A form for the creation of practical lessons. The teacher can generate the content of a course or practice more comfortably with an editor that would allow seeing instantly the result of what is being accomplished, without having to wait to enter the content in the system, as at present. Collaborative work. In the practical classes, team work is a common practice. Normally the students form groups of at least two people. The proposed improvement should allow the exercise to be resolved together and made available to all members of the group by simply indicating the components. Statistics and assessment mode. For the teacher to control better students work, we could include the possibility of observing the content that they are adding to the practices. In additions statistics on the time that they have been writing code, the days that they have accessed the system, attempts to run the program etc could be made available. Scheduled access. To control the access of students to the practical lessons you can add controlled access so that it is made available to the student only during a period of time determined by the teacher. Running in Debugging mode. Students can run the remote server but may not have any tools to debug it. Adding support for using a debugger requires that students add breakpoints and view the contents of the variables when a stop occurs. The utilization of GDB by various IDEs has been investigated and, as future work, the use of the GDBMI interface of GDB is proposed in order to add the possibility of carrying out traces and debug programs in future versions of the tool. GDBMI is short for "GDB machine interface". It is a mode of GDB where the messages provided by the debugger meet a syntax that is easier to analyze by a program, that is, it is designed for being processed by a parser more than by a human being. Since the GDB server is already used for program control, you can adapt the debugger for this extension. Exam mode. Practice tests are often performed using paper. Although at present using the computer is common practice, among the various advantages and possible reasons for conducting exams using this tool, we emphasize the following: 82/100

83 In a computer data may be lost if there is a fault or a power failure while on paper it is much more difficult to lose an exam. It is also more difficult to establish that the writing of a student is false than to verify the authorship of a file generated on a computer system. In addition it is relatively easy for the student to copy if the computer has network access. Thus they can not only copy the solution but access theory notes, similar programs or even communicate with others during an exam. Despite these disadvantages, we believe that this is a feature that would enhance the usefulness due to the ability of centralizing test exercises in the system. In addition, if sufficient precautions are taken, problems could be avoided. We think that a test mode is easy to implement in a web environment combining the possibility of applying the full screen mode with the detection of the loss of focus of the application. You can also include semi-automatic mechanisms for detecting possible copies. In this case, there would be much more information available since not only the final result but also the intermediate stages of program development are presented. Loss of focus. Add a function mode in which the system detects no activity and that the student is not performing the practice but is distracted with something else or, in the case of an exam, the student could be accessing or a chat service in order to contact someone who could provide the answers of the test. Chat and remote control. The possibility that students ask the teacher questions through a chat may be important in the application. Hence, one of the proposed improvements is to add a chat system whereby students can consult the teacher or the Course creator. This could be accompanied by a mechanism by which the teacher can remotely inspect the student s course or practice and even momentarily assume the control of the exercise so that students could see what the teacher does in order to correct a specific question. This would further facilitate the use of the application in distance learning environments. 83/100

84 8 Appendix 8.1 Server.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT 5600 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error lol!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = INADDR_ANY; 84/100

85 //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &s_op, sizeof(s_op)) == -1) { perror("setsockopt"); exit(1); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request //which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, 85/100

86 else &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); return 0; 8.2 Server1.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT 5400 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method 86/100

87 int main() { int fd,fd2; int s_op = 1; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = INADDR_ANY; //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &s_op, sizeof(s_op)) == -1) { perror("setsockopt"); exit(1); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection 87/100

88 if(listen(fd, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); 88/100

89 8.3 Server2.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT 5600 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2; int s_op = 1; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = inet_addr(" "); //short, network byte order 89/100

90 server.sin_port = htons(port); bzero(&(server.sin_zero),8); if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &s_op, sizeof(s_op)) == -1) { perror("setsockopt"); exit(1); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client 90/100

91 if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); 8.4 Server3.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> // The port users will be connecting to #define PORT 5600 // The number of allowed connections #define BACKLOG 5 // Now to define our server. The structure will form inside the our main method int main() { int fd,fd2,fd3; int s_op = 1; struct sockaddr_in server; struct sockaddr_in client; int sn_size; //my address information of server //the address of client 91/100

92 if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1) { printf("server-socket() error!\n"); exit(-1); else printf("server-socket() is OK...\n"); //host byte order server.sin_family = AF_INET; //Automatically fill with server IP server.sin_addr.s_addr = INADDR_ANY; //short, network byte order server.sin_port = htons(port); bzero(&(server.sin_zero),8); // Must say to the system (using setsockopt) to immediately release the port -- was not your fault if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &s_op, sizeof(s_op)) == -1) { perror("setsockopt"); exit(1); //After creating socket descriptor, a bind() gets a name for the socket. if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("server-bind() error\n"); exit(-1); else printf("server-bind() is OK...\n"); //the listen() function allows the server to accept clients connection if(listen(fd3, BACKLOG) == -1) { printf("server-listen() error\n"); exit(-1); else 92/100

93 printf("server-listen() is OK...Ready for listening...\n\n"); while (1) { sn_size = sizeof(struct sockaddr_in); //the accept () function provides the connecting request which does the following: //is part of the same address family //use streams socket tcp //attempts to connect to the specified port if((fd2 = accept(fd,(struct sockaddr*)&client, &sn_size))==-1){ printf("server-accept() error\n"); exit(-1); else printf("server-accept() is OK...\n"); printf("server: Got connection from %s\n", inet_ntoa(client.sin_addr)); //the send() function sends the message to the client if(send(fd2, "This is a test string from server!\n",37,0) == -1){ else printf("server-send() error\n"); exit(-1); printf("server-send() is OK...\n"); close(fd2); 93/100

94 8.5 Client.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <netinet/in.h> #include <netdb.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define PORT 5600 #define MAXDATASIZE 1500 //Funcion main, orden de parametros: IP destino, puerto, mensaje. int main (int argc, char *argv[]) { int fd,numbytes; char buf[maxdatasize]; struct hostent *he; struct sockaddr_in server; if (argc!=2) { printf("usa: %s Give <Direccion IP>\n", argv[0]); exit(-1); printf("%s\n",argv[1]); if ((he=gethostbyname(argv[1]))==null) { printf("error in gethosbynamen() error\n"); exit(-1); if ((fd=socket(af_inet, SOCK_STREAM, 0))==-1) { printf("socket() error\n"); exit(-1); server.sin_family = AF_INET; server.sin_port = htons(port); server.sin_addr = *((struct in_addr *)he->h_addr); bzero(&(server.sin_zero),8); if (connect(fd, (struct sockaddr *)&server, sizeof(struct sockaddr))==-1) { printf("connect() error\n"); exit(-1); 94/100

95 if ((numbytes=recv(fd,buf,maxdatasize,0))==-1) { printf("error in recv() \n"); exit(-1); buf[numbytes]=0; printf("message received from server: %s\n",buf); close(fd); 8.6.RSpec?xml version='1.0'?> <rspec xmlns=" type="request" generated_by="jfed RSpec Editor" generated=" t17:34: :00" xmlns:emulab=" xmlns:jfedbonfire=" xmlns:delay=" xmlns:jfedcommand=" xmlns:client=" xmlns:jfed-sshkeys=" xmlns:jfed=" xmlns:sharedvlan=" xmlns:xsi=" xsi:schemalocation=" <node client_id="client1" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="189.0" y="120.0"/> <interface client_id="client1:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="server1" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> 95/100

96 <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="520.0" y="201.0"/> <interface client_id="server1:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="client2" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="189.0" y="120.0"/> <interface client_id="client2:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="server2" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="520.0" y="201.0"/> <interface client_id="server2:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="client3" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="189.0" y="120.0"/> <interface client_id="client3:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="server3" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> 96/100

97 <location xmlns=" x="520.0" y="201.0"/> <interface client_id="server3:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="client4" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="189.0" y="120.0"/> <interface client_id="client4:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="server4" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="520.0" y="201.0"/> <interface client_id="server4:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="client5" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="189.0" y="120.0"/> <interface client_id="client5:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <node client_id="server5" exclusive="true" component_manager_id="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"> <sliver_type name="raw-pc"/> <services> <execute shell="sh" command="sudo apt-get install dstat"/> <install install_path="/local" url=" </services> <location xmlns=" x="520.0" y="201.0"/> <interface client_id="server5:if0"/> <jfed:nodedescription>physical-node</jfed:nodedescription> </node> <link client_id="link1"> 97/100

98 <component_manager name="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"/> <interface_ref client_id="client1:if0"/> <interface_ref client_id="server1:if0"/> <link_type name="lan"/> <property source_id="client1:if0" dest_id="server1:if0" capacity="100000" latency="2"/> <property source_id="server1:if0" dest_id="client1:if0" capacity="100000" latency="2"/> </link> <link client_id="link2"> <component_manager name="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"/> <interface_ref client_id="client2:if0"/> <interface_ref client_id="server2:if0"/> <link_type name="lan"/> <property source_id="client2:if0" dest_id="server2:if0" capacity="100000" latency="2"/> <property source_id="server2:if0" dest_id="client2:if0" capacity="100000" latency="2"/> </link> <link client_id="link3"> <component_manager name="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"/> <interface_ref client_id="client3:if0"/> <interface_ref client_id="server3:if0"/> <link_type name="lan"/> <property source_id="client3:if0" dest_id="server3:if0" capacity="100000" latency="2"/> <property source_id="server3:if0" dest_id="client3:if0" capacity="100000" latency="2"/> </link> <link client_id="link4"> <component_manager name="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"/> <interface_ref client_id="client4:if0"/> <interface_ref client_id="server4:if0"/> <link_type name="lan"/> <property source_id="client4:if0" dest_id="server4:if0" capacity="100000" latency="2"/> <property source_id="server4:if0" dest_id="client4:if0" capacity="100000" latency="2"/> </link> <link client_id="link5"> <component_manager name="urn:publicid:idn+wall1.ilabt.iminds.be+authority+cm"/> <interface_ref client_id="client5:if0"/> <interface_ref client_id="server5:if0"/> <link_type name="lan"/> <property source_id="client5:if0" dest_id="server5:if0" capacity="100000" latency="2"/> <property source_id="server5:if0" dest_id="client5:if0" capacity="100000" latency="2"/> </link> <jfed-ssh-keys:user-ssh-keys user="urn:publicid:idn+wall2.ilabt.iminds.key_private "> PRIVATE KEY </rspec> 98/100

99 9 Bibliography and reference fed4fire.eu/ Number of OpenFlow switches As defined in FIWARE D3.7 - Methodologyand tools for the determination of infrastructures requirements and for thedetection of Common Enablers and Interoperability constraints Fed4FIRE testbed overview: ICT FIRE overview: (only available upon request) Khan Academy. The MongoDB Manual. Codeacademy. Codelearn. Codeschool. Coursera. Udacity. Udemy. 99/100

100 Miriadax. J.C.W. Debuse and M. Lawley. The learning and productivity benefits to student programmers from real-world development environments 100/100