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 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)