COBIT Planning Assignment Help
Data Modeling and Warehousing
Institution Affiliation
Name
Date
Data warehousing can be described as a centralized storehouse that reserves data from various info sources such like marketing, sales, in supply chain management among others. This is aimed at changing the information into understandable models with are easy for analysis and querying in instances like universities.
A university is a large organization which becomes very complex when trying to identify the best business drivers. In that case, software makers give out programs that aid in assisting big institutions in identifying and monitoring their business drivers. The best business drive that a university can adopt is data warehousing that stores data from multiple sources and this is enabled by the enterprise resource planning software. Most universities face difficulties when it comes to sorting and arranging data that exists with the new data. For instance in a case of a certain university in the United States, they had to acquire and get their data manually which is very tiresome and a lot of time is wasted. In additional, the university also had to incur a lot when updating their new infrastructure due to update in technology college essay help.
Using softweb gave the university an organized view of the important data in the institution and which included a data warehousing solution. With good and organized dashboards, it has become very easy for the university to analyze, get clear statistics and also maintain contracts within the organization. We can argue that in the coming ten years that all big institutions that will not have been grounded deeply embedded in their way of their business model will have a likelihood of ceasing to exist (Jarke, 2013).
Transactional systems are best used for class enrolment because it a type of information system that compiles, stores, reorganizes and reclaims all data transactions of an institution. The transactional systems have components similar to those of quick enroll component. The transactional processing system reduces workload and gives out accurate information needed when enrolling students. This system has certain features that are considered important when enrolling learners. The first one is performance which is measured by a good number of transactions made in the certain period. The system is also always available in all this process of class enrollment. Most institutions depend on transactional processing system since it does not disrupt operations being carried out.
Transactional system is able to handle both software and hardware issues without corrupting the existing data. The large numbers of users have the right to be protected from attempts of interfering with data. The system is also very easy to use and helps the users avoid data entry errors as much as possible. This system is flexible for growth and does not require any replacement. It is easy to add, change or even replace hardware and software components and does not require shutting down the whole system.
Transactional systems might fail to work due to various reasons such as human errors, system and hardware failures, data which is invalid or wrong, viruses, software errors or even disasters caused by nature or man. It might not be possible to prevent all this errors from the systems but TPS is able to detect the errors and cope up with them (Bog, 2014).
A university should always be updated on the new technology to ensure their infrastructure is good. The institution should also come up with the best business drives to ensure that their data is secure and also be able to allocate data when needed. Universities need to use the best systems to ensure that they run their programs effectively and avoid any errors.
References
Bog, A. (2014). Benchmarking transaction and analytical processing systems: The creation of a mixed workload benchmark and its application. Berlin: Springer. Assignment help
Jarke, M. (2013). Fundamentals of data warehouses. Berlin: Springer.
Archive.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# server.py
#
# Copyright 2014 Recursos Python - www.recursospython.com
#
#
from socket import socket, error
def main():
s = socket()
# Escucharpeticionesen el puerto 6030.
s.bind(("localhost", 6030))
s.listen(0)
conn, addr = s.accept()
f = open("recibido.jpg", "wb")
while True:
try:
# Recibirdatos del cliente.
input_data = conn.recv(1024)
except error:
print("Error de lectura.")
break
else:
if input_data:
# Compatibilidad con Python 3.
if isinstance(input_data, bytes):
end = input_data[0] == 1
else:
end = input_data == chr(1)
if not end:
# Almacenardatos.
f.write(input_data)
else:
break
print("El archivo se ha recibidocorrectamente.")
f.close()
if __name__ == "__main__":
main()
Clinen2.py
import socket
import os
import subprocess
s = socket.socket()
host = '127.0.0.1'
port = 1234
#def main():
s.connect((host, port))
while True:
f = open("archivo.jpg", "rb")
content = f.read(1024)
while content:
# Enviarcontenido.
s.send(content)
content = f.read(1024)
break
while True:
data = s.recv(1024)
if len(data) > 0:
if data.decode("utf-8") == "ping":
s.send(str.encode("pong"))
else:
print("[Server] " + data.decode("utf-8"))
try:
s.send(chr(1))
except TypeError:
# Compatibilidad con Python 3.
s.send(bytes(chr(1), "utf-8"))
# Cerrarconexión y archivo.
s.close()
f.close()
print("El archivo ha sidoenviadocorrectamente.")
Server2.py
import socket
import sys
import threading
import time
from queue import Queue
NUMBER_OF_THREADS = 2
JOB_NUMBER = [1,2]
queue = Queue()
all_connections = []
all_address = []
flag_msg = False
# Create a Socket ( connect two computers)
def create_socket():
try:
global host
global port
global s
host = ""
port = 1234
s = socket.socket()
except socket.error as msg:
print("Socket creation error: " + str(msg))
# Binding the socket and listening for connections
def bind_socket():
try:
global host
global port
global s
print("Binding the Port: " + str(port)+"\n")
s.bind((host, port))
s.listen(5)
except socket.error as msg:
print("Socket Binding error" + str(msg) + "\n" + "Retrying...")
bind_socket()
def accepting_connection():
for c in all_connections:
c.close()
del all_connections[:]
del all_address[:]
while True:
try:
conn, address = s.accept()
s.setblocking(1) #Prevents Timeout
all_connections.append(conn)
all_address.append(address)
print("[ New Slave ] [ IP : ", address[0] , " ] [ PORT : " , address[1] , " ]")
recvmsg(conn,address)
except socket.error as msg:
print("Error Accepting Connections: "+msg)
def start_menu():
while True:
server_input = input("> ")
if (server_input=='list'):
list_slaves()
elif('select' in server_input):
conn = get_slave(server_input)
if (conn is not None):
send_msg_to_slave(conn)
else:
print("[ Command not found ]")
def list_slaves():
results = ""
for i, conn in enumerate(all_connections):
try:
conn.send(str.encode("ping"))
conn.recv(201480)
except:
del all_connections[i]
del all_address[i]
continue
results = results + str(i) + " " + str(all_address[i][0]) + " " + str(all_address[i][1]) + "\n"
print("---- SLAVES ----" + "\n" + results)
def get_slave(server_input):
try:
slave_id = server_input.replace('select ','')
slave_id = int(slave_id)
conn = all_connections[slave_id]
print("[ Connected to "+ str(all_address[slave_id][0]) +" ]")
print(str(all_address[slave_id][0]) + ">",end="")
return conn
except:
print("[NOT VALID ID]")
return None
def send_msg_to_slave(conn):
while True:
try:
msg = input("")
if msg == "quit":
break
if len(str.encode(msg)) > 0:
conn.send(str.encode(msg))
except:
print("[Error sending msg to Slave]")
def start_threads():
for _ in range(NUMBER_OF_THREADS):
t = threading.Thread(target=work)
t.daemon = True
t.start()
def recvmsg(conn,addr):
f = open("recibido.py", "wb")
while True:
try:
# Recibirdatos del cliente.
input_data = conn.recv(1024)
except error:
print("Error de lectura.")
break
else:
if input_data:
# Compatibilidad con Python 3.
if isinstance(input_data, bytes):
end = input_data[0] == 1
else:
end = input_data == chr(1)
if not end:
# Almacenardatos.
f.write(input_data)
else:
break
print("El archivo se ha recibidocorrectamente.")
f.close()
def work():
while True:
x = queue.get()
if x==1:
create_socket()
bind_socket()
accepting_connection()
if x==2:
start_menu()
queue.task_done()
def create_jobs():
for x in JOB_NUMBER:
queue.put(x);
queue.join()
start_threads()
create_jobs()
Corrected Server.py
import socket
import sys
import threading
con=threading.Condition()
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host='192.168.1.101'
port=1234
data=''
true=True
s.bind((host,port))
s.listen(5)
def clientin(c,name):
global true,data
while true:
try:
t=c.recv(1024).decode('utf8')
if not t:
c.close()
return
NotifyAll(t)
print(data)
except:
NotifyAll(name+'Exit')
print(data)
return
def NotifyAll(word):
global true,data
if con.acquire():
data=word
con.notifyAll()
con.release()
def clientout(c,name):
global true,data
while true:
if con.acquire():
con.wait()
if data:
try:
c.send(data.encode('utf8'))
con.release()
except:
con.release()
return
print('Chat Established')
while true:
c,addr=s.accept()
print('Connected to slave'+addr[0])
name=c.recv(1024).decode('utf8')
NotifyAll('welcome'+name+'Slave')
print(data)
cin=threading.Thread(target=clientin,args=(c,name))
cin.start()
cout=threading.Thread(target=clientout,args=(c,name))
cout.start()
s.close()
Corrected Client.py
#!/usr/bin/python
"""
client.py
simple port knocking client
Usage: ./client.py <server address> <udp_port1> <udp_port2> ... <tcp_port>
{ikalantzis, vrachnis}@ceid.upatras.gr
"""
import socket
import sys
import time
def knock(sock, port, host):
""" Ping the given host:port """
sock.sendto('PING', (host, port))
print "PING on %s:%s..." % (host, port) ,
# dont wait to print PONG
sys.stdout.flush()
try:
data, server = sock.recvfrom(100)
except socket.timeout:
print "Connection timeout."
return False
if data != 'PONG':
print "Invalid server response (not PONG)"
return False
print "PONG!"
return True
def run(host, ports, tcpport):
""" Begin the port-knocing sequence """
udpsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# timeout after 3 secs, should be enough
udpsock.settimeout(3)
for port in ports:
if not knock(udpsock, port, host):
sys.exit()
# give the server some time to prepare
time.sleep(0.1)
if not opentcp(tcpport, host):
sys.exit()
def opentcp(port, host):
""" Open the TCP connection after the port-knocking sequence """
tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
tcpsock.connect((host, port))
tcpsock.send('PING')
except socket.error:
print "Connection refused."
return False
print tcpsock.recv(100)
tcpsock.close()
return True
def getopts(args):
""" Validate command line arguments """
if len(args) < 3:
print "Wrong parameters"
sys.exit()
# first argument is the server addr
host = args[0]
# the last is the tcp port
tcp = args[-1]
# the rest are udp ports
udp = args[1:-1]
try:
# validate host, we also support hostnames
host = socket.gethostbyname(args[0])
except socket.error:
print "Unknown server address."
sys.exit()
try:
# convert string parameters to ints
return host, [int(x) for x in udp], int(tcp)
except ValueError:
print "Wrong parameters."
sys.exit()
if __name__ == '__main__':
host, ports, tcp = getopts(sys.argv[1:])
print "Server address: %s \nUDP ports: %s \nTCP port: %s \n" % (host, ports, tcp)
run(host, ports, tcp)