Come creare un nuovo Perfect Project da zero (server Swift) in xcode?

Question

Perfect è un nuovo framework Swift per la creazione di un server web/http in modo rapido. La documentazione non è ancora disponibile e trovo problemi con la creazione di un nuovo progetto da zero. Non so quali framework sono necessari per l'importazione e quale è il punto di accesso dell'app. main.swift etc ...

Mi piacerebbe creare un nuovo xcworkspace che avrà il mio progetto, "un server mondiale ciao".

Problemi sto cercando di affrontare:

• Quali quadri devono essere incluse?
• Come dovrei creare un server perfetto, qual è il punto di ingresso dell'app?
• Come creare una radice "hello" che risponde con un "messaggio Hello World"?
• Come dovrei rendere il target per il server ed eventualmente eseguire il server?

Answer 1

Sono riuscito a scrivere una guida "Hello World" su questo. http://code-me-dirty.blogspot.co.uk/2016/02/creating-perfect-swift-server.html

In poche parole è necessario procedere in questo modo:

1. clone del progetto originario
2. Creare una nuova area di lavoro
3. Creare un nuovo progetto
4. Importa PerfectLib.xcodeproject & Importa PerfectServer. xcodeproject ma non copiare
5. Imposta lo schema del tuo progetto per avviare l'app PerfectServer HTTP
6. collegamento del PerfectLib Onn i "quadri collegati e Biblioteche" nella sezione di configurazione
7. Costruire le impostazioni per il vostro target framework *

8. Creare PerfectHandlers.swift e incolla (meglio scrivere per avere la sensazione) il seguente codice

   import PerfectLib 
   //public method that is being called by the server framework to initialise your module. 
   public func PerfectServerModuleInit() { 
   
       // Install the built-in routing handler. 
       // Using this system is optional and you could install your own system if desired. 
       Routing.Handler.registerGlobally() 
   
       // Create Routes 
       Routing.Routes["GET", ["/", "index.html"] ] = { (_:WebResponse) in return IndexHandler() } 
   
       // Check the console to see the logical structure of what was installed. 
       print("\(Routing.Routes.description)") 
   } 
   
   //Create a handler for index Route 
   class IndexHandler: RequestHandler { 
   
       func handleRequest(request: WebRequest, response: WebResponse) { 
        response.appendBodyString("Hello World") 
        response.requestCompletedCallback() 
       } 
   } 
   

Allora sei pronto per correre. Sul mio blog ho una versione lunga e più dettagliata di questo e aggiornerò qui se necessario.

impostazioni di generazione

• distribuzione di locazione: Si
• Installazione realizzare prodotti Località: $ (CONFIGURATION_BUILD_DIR)
• Directory di installazione:/PerfectLibraries
• Skip Installare: NO

Answer 2

Non sono sicuro se hai trovato una soluzione o no, ma questo è quello che ho fatto:

La 'Tap Tracker' applicazione è un app scritto le biblioteche perfetto, quindi, anche se la documentazione non è ancora pronto puoi ancora sezionare l'app. Ho rinominato l'app e le classi/i metodi. C'è un singolo index.html, che ho spostato in una radice 'www', quindi ho reindirizzato la vista con TTHandler per provare a creare un layout standard. Non funziona molto bene perché la struttura è così giovane, ma può essere fatta. Sarei molto più specifico, ma per il momento sono tornato ai binari perché voglio aspettare che sia un po 'più maturo.

È divertente scherzare, e probabilmente scriverò la mia libreria in cima alla perfetta innovazione di funzionalità onc e riuscirò a creare qualcosa di stabile con esso.

Answer 3

I ho appena scritto un tutorial che voglio condividere come un'altra soluzione che delinea come creare un servizio web con Perfect e un'app per interagire con esso.

http://chrismanahan.com/creating-a-web-service-swift-perfect

Sommario

1. è necessario avere il progetto in uno spazio di lavoro. Questo spazio di lavoro dovrebbe includere anche i progetti PerfectServer e PerfectLib.

2. Nel progetto, creare un nuovo target OSX quadro. Questo sarà il vostro target di server

3. link PerfectLib sia con il vostro target server e di destinazione della tua app (se si sta costruendo un app a fianco del server)

4. Modifica lo schema di esecuzione del server da avviare con l'app HTTP PerfectServer.

5. In Parametri di compilazione del Target Server, impostare i seguenti flag:

   • Skip install = No
   • Deployment Posizione = Sì
   • Directory di installazione =/PerfectLibraries
   • Installazione realizzare prodotti Posizione = $ (CONFIGURATION_BUILD_DIR)

6. Creare un nuovo file nella cartella del server. Questo file gestirà le richieste che arrivano.Includere [la maggior parte del] la seguente:

   import PerfectLib 
   
   // This function is required. The Perfect framework expects to find this function 
   // to do initialization 
   public func PerfectServerModuleInit() { 
   
       // Install the built-in routing handler. 
       // This is required by Perfect to initialize everything 
       Routing.Handler.registerGlobally() 
   
       // These two routes are specific to the tutorial in the link above. 
       // This is where you would register your own endpoints. 
       // Take a look at the docs for the Routes API to better understand 
       // everything you can do here 
   
       // register a route for gettings posts 
       Routing.Routes["GET", "/posts"] = { _ in 
        return GetPostHandler() 
       } 
   
       // register a route for creating a new post 
       Routing.Routes["POST", "/posts"] = { _ in 
        return PostHandler() 
       } 
   } 
   
   class GetPostHandler: RequestHandler { 
       func handleRequest(request: WebRequest, response: WebResponse) { 
        response.appendBodyString("get posts") 
        response.requestCompletedCallback() 
       } 
   } 
   
   class PostHandler: RequestHandler { 
       func handleRequest(request: WebRequest, response: WebResponse) { 
        response.appendBodyString("creating post") 
        response.requestCompletedCallback() 
       } 
   } 
   

Come si sta costruendo fuori diversi aspetti del vostro servizio, è possibile testarlo utilizzando cURL nella riga di comando, o altri strumenti di REST testare come Postman

Se vuoi approfondire e imparare come integrarlo con un database SQLite o creare un'app che dialoghi con il tuo nuovo server, consulta il tutorial in cima a questo post.

Answer 4

basta copiare tutti i file da una delle campione progetti al repository git: https://github.com/PerfectExamples

Rinominare l'example_project_name in tutti i file (che avete copiato) al nome del progetto.

Nel terminale di corsa

swift package generate-xcodeproj 

E si otterrà un progetto perfetto con il nome richiesto.

Answer 5

Consiglierei di stare lontano dai modelli, come altri hanno suggerito, e creare un progetto pulito da soli.

creare questa struttura di cartelle:

MyAPI 
├── Package.swift 
└── Sources 
    └── main.swift 

Poi, nel Package.swift file di

import PackageDescription 

let package = Package(
    name: "MyAPI", 
    targets: [], 
    dependencies: [ 
     .Package(url: "https://github.com/PerfectlySoft/Perfect-HTTPServer.git", majorVersion: 2) 
    ] 
) 

e il file main.swift:

import PerfectHTTP 
import PerfectHTTPServer 

do { 

    let route = Route(method: .get, uri: "/hello", handler: { (request: HTTPRequest, response: HTTPResponse) in 
     response.appendBody(string: "world!") 
     response.completed() 
    }) 

    try HTTPServer.launch(.server(name: "localhost", port: 8080, routes: [route])) 

} catch { 
    fatalError("\(error)") 
} 

Vai riga di comando ed esecuzione:

swift package generate-xcodeproj 

Aprire il file di progetto generato:

MyAPI.xcodeproj 

cambiare lo schema attivo, quindi compilare ed eseguire:

aperto in Safari:

http://localhost:8080/hello