def quitarMaquinista():
print('quitarMaquinista')
nombre = request.form.get('nombre')
maquinista = Maquinista.query.filter_by(nombre_m=nombre).first()
if maquinista is None:
return redirect(
url_for('webRoutes.quitMaquinistas', error_maquinista=True))
else:
db.session.delete(maquinista)
db.session.commit()
STORAGE_ACCOUNT_NAME = 'ficherosmaquinistas'
STORAGE_ACCOUNT_KEY = 'JKGDYu80C4HWg6DxUyA8mWYouPVAHV9tlB8MO6Xcv5sFKR7KVr+Onw7PLwP7KjMqhdPKTCWFk59NM4m+t/lcGQ=='
account = CloudStorageAccount(STORAGE_ACCOUNT_NAME,
STORAGE_ACCOUNT_KEY)
file_service = account.create_file_service()
files = list(
file_service.list_directories_and_files(
'shareficherosmaquinistas', prefix=maquinista.nombre_m))
for file in files:
print(file.name)
file_service.delete_file("shareficherosmaquinistas", None,
file.name)
print("--------------------")
return redirect(
url_for('webRoutes.quitMaquinistas', ok_maquinista=True))
def addLogTurno():
print("addLogTurno")
try:
nombreMaquinista = request.form.get('nombreMaquinista')
nombreTurno = request.form.get('nombreTurno')
fecha = request.form.get('fecha')
hora = request.form.get('hora')
contenido = request.form.get('contenido')
emergencia = request.form.get('emergencia')
nombreDelFichero = ""
if emergencia is None:
nombreDelFichero = nombreMaquinista + "," + nombreTurno + ",Fecha " + fecha + " Hora " + hora + ".txt"
else:
nombreDelFichero = nombreMaquinista + "," + nombreTurno + ",Fecha " + fecha + " Hora " + hora + ",emergencia.txt"
pusher_client.trigger(
'my-channel', 'my-event', {
'maquinista': nombreMaquinista,
'turno': nombreTurno,
'fecha': fecha,
'nombreFichero': nombreDelFichero
})
lista_split = contenido.split(";")
texto = ""
for i in lista_split:
texto = texto + i + "\n"
STORAGE_ACCOUNT_NAME = 'ficherosmaquinistas'
STORAGE_ACCOUNT_KEY = 'JKGDYu80C4HWg6DxUyA8mWYouPVAHV9tlB8MO6Xcv5sFKR7KVr+Onw7PLwP7KjMqhdPKTCWFk59NM4m+t/lcGQ=='
account = CloudStorageAccount(STORAGE_ACCOUNT_NAME,
STORAGE_ACCOUNT_KEY)
file_service = account.create_file_service()
file_service.create_file_from_text("shareficherosmaquinistas", None,
nombreDelFichero, texto)
except:
return "turnoFalseAdd"
return "turnoTrueAdd"
def ficherosTurno():
print("ficherosTurno")
maquinistaID = request.args.get('maquinista_arg')
turno_actID = request.args.get('turno_arg')
maquinista = Maquinista.query.filter_by(id=maquinistaID).first()
turno_act = Turno.query.filter_by(id=turno_actID).first()
print(maquinista.nombre_m)
print(turno_act.nombre_t)
pattern = maquinista.nombre_m + "," + turno_act.nombre_t
print(pattern)
ficheros_logs = []
fechas_ficheros = []
STORAGE_ACCOUNT_NAME = 'ficherosmaquinistas'
STORAGE_ACCOUNT_KEY = 'JKGDYu80C4HWg6DxUyA8mWYouPVAHV9tlB8MO6Xcv5sFKR7KVr+Onw7PLwP7KjMqhdPKTCWFk59NM4m+t/lcGQ=='
account = CloudStorageAccount(STORAGE_ACCOUNT_NAME, STORAGE_ACCOUNT_KEY)
file_service = account.create_file_service()
files = list(
file_service.list_directories_and_files('shareficherosmaquinistas',
prefix=pattern))
print("busqueda de ficheros")
for file in files:
print(file.name)
textos = file.name.split(',')
print(textos)
ficheros_logs.append(file.name)
valores = textos[2].split('.txt')
print(valores)
fechas_ficheros.append(valores[0])
print("---------")
context = {
'ficheros_logs': ficheros_logs,
'fechas_ficheros': fechas_ficheros,
'nombre_turno': turno_act.nombre_t
}
return render_template('ficherosTurno.html', **context)
def logsTurno():
print("logsTurno")
nombre = request.args.get('nombre_fichero_arg')
STORAGE_ACCOUNT_NAME = 'ficherosmaquinistas'
STORAGE_ACCOUNT_KEY = 'JKGDYu80C4HWg6DxUyA8mWYouPVAHV9tlB8MO6Xcv5sFKR7KVr+Onw7PLwP7KjMqhdPKTCWFk59NM4m+t/lcGQ=='
account = CloudStorageAccount(STORAGE_ACCOUNT_NAME, STORAGE_ACCOUNT_KEY)
file_service = account.create_file_service()
file_and_contenido = file_service.get_file_to_text(
'shareficherosmaquinistas', None, nombre)
filas = file_and_contenido.content.split('\n')
print(filas)
context = {
'fecha': request.args.get('fecha_fichero_arg'),
'nombre_turno': request.args.get('nombre_turno_arg'),
'filas': filas
}
return render_template('logsTurno.html', **context)
class StorageAccountTest(StorageTestCase):
def setUp(self):
super(StorageAccountTest, self).setUp()
self.account_name = self.settings.STORAGE_ACCOUNT_NAME
self.account_key = self.settings.STORAGE_ACCOUNT_KEY
self.sas_token = '?sv=2015-04-05&st=2015-04-29T22%3A18%3A26Z&se=2015-04-30T02%3A23%3A26Z&sr=b&sp=rw&sip=168.1.5.60-168.1.5.70&spr=https&sig=Z%2FRHIX5Xcg0Mq2rqI3OlWTjEg2tYkboXr1P9ZUXDtkk%3D'
self.account = CloudStorageAccount(self.account_name, self.account_key)
# --Helpers-----------------------------------------------------------------
def validate_service(self, service, type):
self.assertIsNotNone(service)
self.assertIsInstance(service, type)
self.assertEqual(service.account_name, self.account_name)
self.assertEqual(service.account_key, self.account_key)
# --Test cases --------------------------------------------------------
def test_create_block_blob_service(self):
# Arrange
# Act
service = self.account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_page_blob_service(self):
# Arrange
# Act
service = self.account.create_page_blob_service()
# Assert
self.validate_service(service, PageBlobService)
def test_create_append_blob_service(self):
# Arrange
# Act
service = self.account.create_append_blob_service()
# Assert
self.validate_service(service, AppendBlobService)
def test_create_queue_service(self):
# Arrange
# Act
service = self.account.create_queue_service()
# Assert
self.validate_service(service, QueueService)
def test_create_file_service(self):
# Arrange
# Act
service = self.account.create_file_service()
# Assert
self.validate_service(service, FileService)
def test_create_service_no_key(self):
# Arrange
# Act
bad_account = CloudStorageAccount('', '')
with self.assertRaises(ValueError):
service = bad_account.create_block_blob_service()
# Assert
def test_create_account_sas(self):
# Arrange
# Act
sas_account = CloudStorageAccount(self.account_name, sas_token=self.sas_token)
service = sas_account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, self.account_name)
self.assertIsNone(service.account_key)
self.assertEqual(service.sas_token, self.sas_token)
def test_create_account_sas_and_key(self):
# Arrange
# Act
account = CloudStorageAccount(self.account_name, self.account_key, self.sas_token)
service = account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_account_emulated(self):
# Arrange
# Act
account = CloudStorageAccount(is_emulated=True)
service = account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, 'devstoreaccount1')
self.assertIsNotNone(service.account_key)
@record
def test_generate_account_sas(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
token = self.account.generate_shared_access_signature(
Services.BLOB,
ResourceTypes.OBJECT,
AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
)
service = self.account.create_block_blob_service()
data = b'shared access signature with read permission on blob'
container_name = 'container1'
blob_name = 'blob1.txt'
try:
service.create_container(container_name)
service.create_blob_from_bytes(container_name, blob_name, data)
# Act
url = service.make_blob_url(
container_name,
blob_name,
sas_token=token,
)
response = requests.get(url)
# Assert
self.assertTrue(response.ok)
self.assertEqual(data, response.content)
finally:
service.delete_container(container_name)
class StorageAccountTest(StorageTestCase):
def setUp(self):
super(StorageAccountTest, self).setUp()
self.account_name = self.settings.STORAGE_ACCOUNT_NAME
self.account_key = self.settings.STORAGE_ACCOUNT_KEY
self.sas_token = '?sv=2015-04-05&st=2015-04-29T22%3A18%3A26Z&se=2015-04-30T02%3A23%3A26Z&sr=b&sp=rw&sip=168.1.5.60-168.1.5.70&spr=https&sig=Z%2FRHIX5Xcg0Mq2rqI3OlWTjEg2tYkboXr1P9ZUXDtkk%3D'
self.account = CloudStorageAccount(self.account_name, self.account_key)
# --Helpers-----------------------------------------------------------------
def validate_service(self, service, type):
self.assertIsNotNone(service)
self.assertIsInstance(service, type)
self.assertEqual(service.account_name, self.account_name)
self.assertEqual(service.account_key, self.account_key)
# --Test cases --------------------------------------------------------
def test_create_block_blob_service(self):
# Arrange
# Act
service = self.account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_page_blob_service(self):
# Arrange
# Act
service = self.account.create_page_blob_service()
# Assert
self.validate_service(service, PageBlobService)
def test_create_append_blob_service(self):
# Arrange
# Act
service = self.account.create_append_blob_service()
# Assert
self.validate_service(service, AppendBlobService)
def test_create_queue_service(self):
# Arrange
# Act
service = self.account.create_queue_service()
# Assert
self.validate_service(service, QueueService)
def test_create_file_service(self):
# Arrange
# Act
service = self.account.create_file_service()
# Assert
self.validate_service(service, FileService)
def test_create_service_no_key(self):
# Arrange
# Act
bad_account = CloudStorageAccount('', '')
with self.assertRaises(ValueError):
service = bad_account.create_block_blob_service()
# Assert
def test_create_account_sas(self):
# Arrange
# Act
sas_account = CloudStorageAccount(self.account_name,
sas_token=self.sas_token)
service = sas_account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, self.account_name)
self.assertIsNone(service.account_key)
self.assertEqual(service.sas_token, self.sas_token)
def test_create_account_sas_and_key(self):
# Arrange
# Act
account = CloudStorageAccount(self.account_name, self.account_key,
self.sas_token)
service = account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_account_emulated(self):
# Arrange
# Act
account = CloudStorageAccount(is_emulated=True)
service = account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, 'devstoreaccount1')
self.assertIsNotNone(service.account_key)
@record
def test_generate_account_sas(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
token = self.account.generate_shared_access_signature(
Services.BLOB,
ResourceTypes.OBJECT,
AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
)
service = self.account.create_block_blob_service()
data = b'shared access signature with read permission on blob'
container_name = 'container1'
blob_name = 'blob1.txt'
try:
service.create_container(container_name)
service.create_blob_from_bytes(container_name, blob_name, data)
# Act
url = service.make_blob_url(
container_name,
blob_name,
sas_token=token,
)
response = requests.get(url)
# Assert
self.assertTrue(response.ok)
self.assertEqual(data, response.content)
finally:
service.delete_container(container_name)
class TaskManager():
def __init__(self, queue):
#read config
self.account = CloudStorageAccount(account_name="pythontasks",
sas_token=SAS)
self.service = self.account.create_file_service()
self.share = queue
self.service.create_share(self.share, fail_on_exist=False)
self.service.create_directory(self.share, TASKS_DIR) # True
self.service.create_directory(self.share, RESULTS_DIR) # True
def addTask(self, name, command):
file_name = name + ".tsk"
self.service.create_file_from_text(self.share, TASKS_DIR, file_name,
command)
def findTask(self):
dir1 = list(
self.service.list_directories_and_files(self.share, TASKS_DIR))
candidates = []
for res in dir1:
#split res.name in
base = os.path.basename(res.name) # strip paths / etc.
name = os.path.splitext(base)[0]
ext = os.path.splitext(base)[1]
if ext == ".tsk":
print("Found a task.")
exists = self.service.exists(self.share, TASKS_DIR,
name + ".lck")
if (exists == False):
candidates.append(name)
if len(candidates) > 0:
return random.choice(candidates)
else:
return ""
def executeTask(self, name):
task_file_name = name + ".tsk"
result_file_name = name + ".res"
# make lck file
self.service.create_file_from_text(self.share, TASKS_DIR,
name + ".lck", "locked")
# read commandline from task file
command = self.service.get_file_to_text(self.share, TASKS_DIR,
task_file_name)
# run the task
print("Starting with taskname {} at {} by executing {}.".format(
name, datetime.datetime.now(), command.content))
result = subprocess.run(command.content,
shell=True,
stdout=PIPE,
stderr=PIPE,
universal_newlines=True)
if (result.returncode == 0):
self.service.create_file_from_text(self.share, RESULTS_DIR,
result_file_name, result.stdout)
else:
self.service.create_file_from_text(self.share, RESULTS_DIR,
result_file_name, str(result))
# remove this task and lock
self.service.delete_file(self.share,
TASKS_DIR,
task_file_name,
timeout=None)
self.service.delete_file(self.share,
TASKS_DIR,
name + ".lck",
timeout=None)
def monitor(self):
while (True):
name = self.findTask()
if (name == ""):
print("No task found. Sleeping for one minute.")
time.sleep(60)
else:
self.executeTask(name)
import azure.storage.common
from azure.storage.common import CloudStorageAccount
STORAGE_ACCOUNT_NAME = 'ficherosmaquinistas'
STORAGE_ACCOUNT_KEY = 'JKGDYu80C4HWg6DxUyA8mWYouPVAHV9tlB8MO6Xcv5sFKR7KVr+Onw7PLwP7KjMqhdPKTCWFk59NM4m+t/lcGQ=='
account = CloudStorageAccount(STORAGE_ACCOUNT_NAME, STORAGE_ACCOUNT_KEY)
file_service = account.create_file_service()
files = list(
file_service.list_directories_and_files('shareficherosmaquinistas',
prefix="filename"))
for file in files:
print(file.name)
ff = file_service.get_file_to_text('shareficherosmaquinistas', None,
file.name)
print(ff.name)
print(ff.content.split('\n'))
print("--------------------")
class StorageAccountTest(StorageTestCase):
def setUp(self):
super(StorageAccountTest, self).setUp()
self.sas_token = '?sv=2015-04-05&st=2015-04-29T22%3A18%3A26Z&se=2015-04-30T02%3A23%3A26Z&sr=b&sp=rw&sip=168.1.5.60-168.1.5.70&spr=https&sig=Z%2FRHIX5Xcg0Mq2rqI3OlWTjEg2tYkboXr1P9ZUXDtkk%3D'
if self.settings.IS_EMULATED:
self.account_name = DEV_ACCOUNT_NAME
self.account_key = DEV_ACCOUNT_KEY
self.protocol = "http"
self.account = CloudStorageAccount(DEV_ACCOUNT_NAME,
DEV_ACCOUNT_KEY,
is_emulated=True)
else:
self.account_name = self.settings.STORAGE_ACCOUNT_NAME
self.account_key = self.settings.STORAGE_ACCOUNT_KEY
self.account = CloudStorageAccount(self.account_name,
self.account_key)
self.protocol = self.settings.PROTOCOL
# --Helpers-----------------------------------------------------------------
def validate_service(self, service, type):
self.assertIsNotNone(service)
self.assertIsInstance(service, type)
self.assertEqual(service.account_name, self.account_name)
self.assertEqual(service.account_key, self.account_key)
# --Test cases --------------------------------------------------------
def test_create_block_blob_service(self):
# Arrange
# Act
service = self.account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_page_blob_service(self):
# Arrange
# Act
service = self.account.create_page_blob_service()
# Assert
self.validate_service(service, PageBlobService)
def test_create_append_blob_service(self):
# Arrange
# Act
service = self.account.create_append_blob_service()
# Assert
self.validate_service(service, AppendBlobService)
def test_create_queue_service(self):
# Arrange
# Act
service = self.account.create_queue_service()
# Assert
self.validate_service(service, QueueService)
@not_for_emulator
def test_create_file_service(self):
# Arrange
# Act
service = self.account.create_file_service()
# Assert
self.validate_service(service, FileService)
def test_create_service_no_key(self):
# Arrange
# Act
bad_account = CloudStorageAccount('', '')
with self.assertRaises(ValueError):
service = bad_account.create_block_blob_service()
# Assert
def test_create_account_sas(self):
# Arrange
# Act
sas_account = CloudStorageAccount(self.account_name,
sas_token=self.sas_token)
service = sas_account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, self.account_name)
self.assertIsNone(service.account_key)
self.assertEqual(service.sas_token, self.sas_token)
def test_create_account_sas_and_key(self):
# Arrange
# Act
account = CloudStorageAccount(self.account_name, self.account_key,
self.sas_token)
service = account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_account_emulated(self):
# Arrange
# Act
account = CloudStorageAccount(is_emulated=True)
service = account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, 'devstoreaccount1')
self.assertIsNotNone(service.account_key)
@record
def test_generate_account_sas(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
token = self.account.generate_shared_access_signature(
Services.BLOB,
ResourceTypes.OBJECT,
AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
)
service = self.account.create_block_blob_service()
data = b'shared access signature with read permission on blob'
container_name = self.get_resource_name("container")
blob_name = 'blob1.txt'
try:
service.create_container(container_name)
service.create_blob_from_bytes(container_name, blob_name, data)
# Act
url = service.make_blob_url(
container_name,
blob_name,
sas_token=token,
)
response = requests.get(url)
# Assert
self.assertTrue(response.ok)
self.assertEqual(data, response.content)
finally:
service.delete_container(container_name)
@record
def test_account_sas_with_question_mark_prefix(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
token = '?' + self.account.generate_shared_access_signature(
Services.BLOB,
ResourceTypes.OBJECT + ResourceTypes.CONTAINER,
AccountPermissions.READ + AccountPermissions.WRITE +
AccountPermissions.DELETE + AccountPermissions.CREATE,
datetime.utcnow() + timedelta(hours=1),
)
service = BlockBlobService(self.account_name,
sas_token=token,
is_emulated=self.settings.IS_EMULATED)
data = b'shared access signature with read/write permission on blob'
container_name = self.get_resource_name("container")
blob_name = 'blob1.txt'
try:
# Act
service.create_container(container_name)
service.create_blob_from_bytes(container_name, blob_name, data)
blob = service.get_blob_to_bytes(container_name, blob_name)
# Assert
self.assertIsNotNone(blob)
self.assertEqual(data, blob.content)
finally:
service.delete_container(container_name)
@record
def test_generate_account_sas_with_multiple_permissions(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Validate both + and | generate the same permissions
permissions = AccountPermissions.READ + AccountPermissions.WRITE
permissions_or = AccountPermissions.READ | AccountPermissions.WRITE
self.assertEqual(str(permissions), str(permissions_or))
# Arrange
token = self.account.generate_shared_access_signature(
Services.BLOB,
ResourceTypes.OBJECT,
permissions,
datetime.utcnow() + timedelta(hours=1),
)
service_with_key = self.account.create_block_blob_service()
service_with_sas = BlockBlobService(
account_name=self.account_name,
sas_token=token,
is_emulated=self.settings.IS_EMULATED)
data = b'shared access signature with read/write permission on blob'
container_name = self.get_resource_name("container")
blob_name = 'blob1.txt'
try:
# Act Write
service_with_key.create_container(container_name)
# wait a few seconds to allow the container to be created
self.sleep(5)
resp = service_with_sas.create_blob_from_text(
container_name, blob_name, data)
# Assert Write
self.assertIsNotNone(resp.etag)
self.assertIsNotNone(resp.last_modified)
# Act Read
blob = service_with_sas.get_blob_to_bytes(container_name,
blob_name)
# Assert Read
self.assertIsNotNone(blob.content)
self.assertEqual(data, blob.content)
finally:
service_with_key.delete_container(container_name)
@record
def test_generate_account_sas_with_multiple_services(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
token = self.account.generate_shared_access_signature(
Services.BLOB + Services.TABLE,
ResourceTypes.SERVICE + ResourceTypes.OBJECT,
AccountPermissions.READ + AccountPermissions.WRITE,
datetime.utcnow() + timedelta(hours=1),
)
self.assertTrue('ss=bt' in token)
# Act Table
# this needs to be hard coded as the table package is no longer maintained here
url = '{}://{}/?restype=service&comp=properties&{}'.format(
self.protocol,
self.account_name + ".table.core.windows.net"
if not self.settings.IS_EMULATED else "127.0.0.1:10002/" +
DEV_ACCOUNT_NAME,
token,
)
response = requests.get(url)
# Assert Table
self.assertTrue(response.ok)
# Act Blob
service_with_key = self.account.create_block_blob_service()
service_with_sas = BlockBlobService(
account_name=self.account_name,
sas_token=token,
is_emulated=self.settings.IS_EMULATED)
data = b'shared access signature with read/write permission on blob'
container_name = self.get_resource_name("container")
blob_name = 'blob1.txt'
try:
# Act Write
service_with_key.create_container(container_name)
resp = service_with_sas.create_blob_from_text(
container_name, blob_name, data)
# Assert Write
self.assertIsNotNone(resp.etag)
self.assertIsNotNone(resp.last_modified)
# Act Read
blob = service_with_sas.get_blob_to_bytes(container_name,
blob_name)
# Assert Read
self.assertIsNotNone(blob.content)
self.assertEqual(data, blob.content)
finally:
service_with_key.delete_container(container_name)
