Skip to content

Latest commit

 

History

History
155 lines (123 loc) · 5.37 KB

flask-server.md

File metadata and controls

155 lines (123 loc) · 5.37 KB
Raw

Aqui está um exemplo de como criar um programa em Python no Windows 10 com uma interface gráfica (usando tkinter) para um servidor Flask que abre uma porta no firewall e permite comunicação com outro PC via uma página web. O programa inclui a criação de um log, renomeação do log, definição da porta, e controle do servidor (ligar/desligar):

Instalação de Dependências

  1. Flask para o servidor web:

    pip install Flask

  2. tkinter (geralmente já incluído no Python).

  3. pywin32 para manipular o firewall do Windows:

    pip install pywin32

Código do Servidor Flask com GUI

import os
import logging
import tkinter as tk
from tkinter import messagebox, filedialog
from flask import Flask, request
import threading
import subprocess
import win32com.client

# Inicializar o Flask
app = Flask(__name__)
servidor_ativo = False

# Função para manipular firewall do Windows
def gerenciar_firewall(porta, acao):
    shell = win32com.client.Dispatch("WScript.Shell")
    comando = f'netsh advfirewall firewall {acao} rule name="FlaskServer" protocol=TCP localport={porta}'
    shell.Run(comando, 0, True)  # Executa o comando de forma silenciosa

# Função para ligar o servidor Flask
def ligar_servidor(porta):
    global servidor_ativo
    servidor_ativo = True

    def iniciar_flask():
        app.run(host="0.0.0.0", port=porta)

    threading.Thread(target=iniciar_flask).start()
    gerenciar_firewall(porta, 'add')
    logging.info(f"Servidor ligado na porta {porta}")

# Função para desligar o servidor Flask
def desligar_servidor(porta):
    global servidor_ativo
    servidor_ativo = False
    gerenciar_firewall(porta, 'delete')
    logging.info(f"Servidor desligado e firewall fechado para a porta {porta}")

# Função para criar e renomear log
def criar_log(caminho):
    logging.basicConfig(filename=caminho, level=logging.INFO, format='%(asctime)s - %(message)s')
    logging.info("Log criado")

# Definir as rotas Flask
@app.route('/')
def index():
    return 'Servidor Flask ativo'

@app.route('/mensagem', methods=['POST'])
def receber_mensagem():
    data = request.json
    logging.info(f"Mensagem recebida: {data}")
    return 'Mensagem recebida', 200

# Funções da interface gráfica
def abrir_log():
    log_caminho = filedialog.asksaveasfilename(defaultextension=".log", filetypes=[("Log files", "*.log")])
    if log_caminho:
        criar_log(log_caminho)
        messagebox.showinfo("Log", f"Log criado em: {log_caminho}")

def iniciar_servidor():
    porta = entrada_porta.get()
    if not porta.isdigit():
        messagebox.showwarning("Erro", "Porta inválida")
        return
    ligar_servidor(int(porta))
    messagebox.showinfo("Servidor", f"Servidor iniciado na porta {porta}")

def parar_servidor():
    porta = entrada_porta.get()
    if not porta.isdigit():
        messagebox.showwarning("Erro", "Porta inválida")
        return
    desligar_servidor(int(porta))
    messagebox.showinfo("Servidor", f"Servidor desligado da porta {porta}")

def sair():
    if servidor_ativo:
        parar_servidor()
    janela.quit()

# Criação da interface gráfica
janela = tk.Tk()
janela.title("Servidor Flask com Firewall")

# Rótulos e campos de entrada
tk.Label(janela, text="Porta:").grid(row=0, column=0)
entrada_porta = tk.Entry(janela)
entrada_porta.grid(row=0, column=1)

# Botões
botao_ligar = tk.Button(janela, text="Ligar Servidor", command=iniciar_servidor)
botao_ligar.grid(row=1, column=0)

botao_desligar = tk.Button(janela, text="Desligar Servidor", command=parar_servidor)
botao_desligar.grid(row=1, column=1)

botao_log = tk.Button(janela, text="Criar Log", command=abrir_log)
botao_log.grid(row=2, column=0)

botao_sair = tk.Button(janela, text="Sair", command=sair)
botao_sair.grid(row=2, column=1)

janela.mainloop()

Explicação Passo a Passo

  1. Importações e Configurações:

    • os, logging, tkinter são usados para manipulação de ficheiros e criação de interface gráfica.
    • Flask serve o conteúdo via HTTP.
    • win32com.client manipula o firewall do Windows.
    • threading permite executar o servidor Flask numa thread separada.

  2. Função gerenciar_firewall:

    • Usa o comando netsh para adicionar ou remover regras no firewall do Windows.
    • O método Run executa o comando silenciosamente.

  3. Funções ligar_servidor e desligar_servidor:

    • Iniciam e param o servidor Flask, controlando também o firewall, permitindo comunicação via rede.

  4. Funções criar_log e receber_mensagem:

    • Cria o log onde as mensagens recebidas são registadas.
    • A rota /mensagem recebe dados via POST e grava no log.

  5. Interface Gráfica:

    • Criada com tkinter com botões para ligar/desligar o servidor, criar log e sair do programa.
    • A entrada de texto permite definir a porta que o servidor usará.

  6. Fluxo de Controle:

    • O servidor Flask é iniciado numa thread separada para que a interface gráfica continue responsiva.
    • Os botões executam as funções que controlam o servidor e manipulam o firewall.

Testando a Comunicação entre PCs

  • Após iniciar o servidor e abrir a porta no firewall, outros PCs podem acessar o servidor Flask via a URL http://<seu_ip>:<porta>.
  • A rota /mensagem pode ser usada para enviar dados via uma requisição POST.

Esse exemplo cobre as funcionalidades básicas, com controle sobre o firewall do Windows e logs.