index.js

var app = require('express')()
var server = app.listen(8080)
var io = require('socket.io')(server)//8080, {path: "", transports: ["polling"], pingInterval: 500})
var fs = require("fs")

// io.use(function(socket, next) {
//     if (socket.request.headers.cookie)  {
//         console.log(socket.request.headers.cookie)
//         return next()
//     }
//
//     next(new Error('Authentication error'))
//
//     // setTimeout(function() {
//     //     if (socket.request.headers.cookie)  {
//     //         console.log(socket.request.headers.cookie)
//     //         return next()
//     //     }
//     //
//     //     next(new Error('Authentication error'))
//     // }, 250001)
// })


var println = console.log

var nsp = io.of("/swift")
nsp.on('connection', function(socket) {
    console.log("Someone joined swift")
        // socket.emit("nspTest", "test from namespace")
        // socket.emit("nspTest", {
        //     test: "test"
        // })
        // socket.emit("nspTestMult", {
        //     data: new Buffer("test")
        // }, 2)

    socket.on("nspBinary", function(data) {
        println(data)
    })

    socket.on("nspTest", function(data) {
        println(data)
    })

    socket.on("echo", function(data) {
        println("Got namespace testEcho")
    })

    socket.on("arrayTest", function(arr) {
        println("Got namespace array test " + arr)
    })
    socket.on("stringTest", function(str) {
        println("Got namepsace string test: " + str)
    })

    socket.on("boolTest", function(bool) {
        println("Got namespace bool test: " + bool)
    })

    socket.on("intTest", function(i) {
        println("Got namespace int test: " + i)
    })

    socket.on("doubleTest", function(dub) {
        println("Got namespace double test: " + dub)
    })

    socket.on("disconnect", function() {
        console.log("nsp leave")
    })

    socket.on("nested", function(data) {
        println("nested test")
        println(data)

        //console.log(data[1]["test2"]["test3"])
    })

    // socket.on("ackack", function(data, ack) {
    //     ack(new Buffer("binary ack"), {
    //         test: "test"
    //     })
    // })

    socket.emit("currentAmount", 2.50, function(str, str2) {
        console.log(str + str2)
    })

    socket.on("update", function(amount) {
        console.log(amount)
    })

    socket.on("canUpdate", function(num, ack) {
        console.log(num)
        ack(true)
    })

    socket.emit("nestedTest", {
        test: new Buffer("testNested")
    }, 2, [2, [new Buffer("testNested2"), {
        test: 1,
        buf: new Buffer("testNested3")
    }]])

    socket.emit("blankTest")
    socket.emit("nullTest", null)
    socket.emit("boolTest", true)
    socket.emit("stringTest", "line one\nline two")

    setTimeout(function() {
        socket.emit("unicodeTest", "πÔÒÔ")
    }, 2000)
    socket.emit("jsonTest", {
        foo: "string\ntest test"
    })
    socket.emit("arrayTest", [2, "test"])
    socket.emit("intTest", 2)
    socket.emit("doubleTest", 2.2)
    socket.emit("dataTest", new Buffer("testData"))
    socket.emit("multipleItems", [new Buffer("test1"), 2], [{test: "bob"}],2, "hello", new Buffer("test2"), "test")
    socket.emit("mult", 1, 2, 3, {
        foo: "bar"
    })

    socket.emit("ackEvent", "gakgakgak", function(re, name) {
        println("Got ack for ackEvent")
        println(re)
        println(name)
    })

    socket.emit("binaryAckEvent", new Buffer("gakgakgak2"), function(bin, str) {
        println(bin)
        println(str)
    })

    socket.emit("multAckEvent", new Buffer("gakgakgak3"), 2, function(re) {
        println(re)
    })
    //socket.emit("nspLeave")
})

// io.on("connection", function(socket) {
// 	console.log(socket.compress)

// 	socket.close()
// })
var closed = false
var timesClosed = 0
var numStress = 0
var before
var burstI

io.sockets.on("connection", function(socket) {
    socket.join("testRoom")
    //socket.disconnect()

    console.log(socket.request._query)
    console.log(socket.request.headers)
    console.log("sid: " + socket.id)

    // var closeTimer = setTimeout(function() {
    //     if (closed) {
    //         clearTimeout(closeTimer)
    //         return
    //     }
    //     console.error("Closing socket")
    //     socket.conn.close()
    //     closed = true
    // }, 2000)
    socket.on("test", function() {
        println("Got test")
    })

    socket.on("jsonTest", function(data) {
        println(data["name"])
    })

    socket.on("disconnect", function() {
        println("disc")
    })

    //socket.emit("test", "test from all")
    println("got connection")

    socket.on("echo", function(data) {
        println("Got testEcho")
    })

    socket.on("arrayTest", function(arr) {
        println("Got array test " + arr)
    })
    socket.on("stringTest", function(str) {
        println("Got string test: " + str)
    })

    socket.on("boolTest", function(bool) {
        println("Got bool test: " + bool)
    })

    socket.on("intTest", function(i) {
        println("Got int test: " + i)
    })

    socket.on("doubleTest", function(dub) {
        println("Got double test: " + dub)
    })

    socket.on("nested", function(data) {
        println("nested test")
        println(data)

        //console.log(data[1]["test2"]["test3"])
    })

    // socket.on("closeTest", function() {
    //     // if (timesClosed < 10) {
    //     //     println("closing socket")
    //     //     socket.conn.close()
    //     //     timesClosed++
    //     // }
    //
    //     socket.disconnect()
    // })

    socket.on("closeTest", function() {
        socket.emit("deinit")
    })

    socket.on("dataTest", function(data) {
        println("Got data test: " + data)
    })

    socket.on("binaryTest", function(data) {
        println(data["binary"])
    })

    socket.on("ackack", function(str, int, ack) {
        console.log("got ackack")
        console.log(int)
            // ack(new Buffer("binary ack"))
        // ack({
        //     code: "200",
        //     message: [{
        //         msg: [{
        //             phone: "276"
        //         }, 2],
        //         name: "bob"
        //     }]
        // }, "test")

        ack(["hi", "hello"])
    })

    socket.on("ackack2", function(data, int, ack) {
        console.log("got ackack2")
        console.log(data)
        console.log(int)
        ack("got ackack2")
    })

    socket.on("rawTest", function(data) {
        println(data)
    })

    socket.on("multData", function(data, data2) {
        println(data)
        println(data2)
    })

    socket.on("stopStress", function() {
        clearInterval(stress)
    })

    socket.on("multTest", function(array, dub, num, string, bool, obj, data) {
        console.log("Got multTest")
            // console.log(array)
            // console.log(dub)
            // console.log(num)
            // console.log(string)
            // console.log(bool)
            // console.log(obj)
            // console.log(data)
    })

    var emitStart
    var emitStressNum = 0
    socket.on("startEmitStress", function() {
        emitStart = new Date().getTime()
    })

    socket.on("emitStress", function() {
        emitStressNum++
    })

    socket.on("endEmitStress", function() {
        var end = new Date().getTime()
        console.log("Got: " + emitStressNum + " events in " + (end - emitStart) + " milliseconds")
    })

    // var burst = function() {
    //     for (var i = 0; i < 10; i++) {
    //         socket.emit("burstTest", [1, [2 + 2, {buf: new Buffer("testBurst" + timesClosed)}]])
    //     }
    // }

    //    burst()

    socket.emit("currentAmount", 2.50, function(str, str2) {
        console.log(str + str2)
    })

    socket.on("update", function(amount) {
        console.log(amount)
    })

    socket.on("canUpdate", function(num, ack) {
        console.log(num)
        ack(true)
    })

    socket.emit("nestedTest", {
        test: new Buffer("testNested")
    }, 2, [2, [new Buffer("testNested2"), {
        test: 1,
        buf: new Buffer("testNested3")
    }]])

    socket.emit("blankTest")
    socket.emit("nullTest", null)
    socket.emit("boolTest", true)
    socket.emit("stringTest", "line one\nline two")

    setTimeout(function() {
        socket.emit("unicodeTest", "πÔÒÔ")
    }, 2000)
    socket.emit("jsonTest", {
        foo: "string\ntest test"
    })
    socket.emit("arrayTest", [2, "test"])
    socket.emit("intTest", 2)
    socket.emit("doubleTest", 2.2)
    socket.emit("dataTest", new Buffer("testData"))
    socket.emit("multipleItems", [new Buffer("test1"), 2], [{test: "bob"}],2, "hello", new Buffer("test2"), "test")
    socket.emit("mult", 1, 2, 3, {
        foo: "bar"
    })

    socket.emit("ackEvent", "gakgakgak", function(re, name) {
        println("Got ack for ackEvent")
        println(re)
        println(name)
    })

    socket.emit("binaryAckEvent", new Buffer("gakgakgak2"), function(bin, str) {
        println(bin)
        println(str)
    })

    socket.emit("multAckEvent", new Buffer("gakgakgak3"), 2, function(re) {
        println(re)
    })
    
})

main.swift

import Cocoa

let testCytube = false
var socket:SocketIOClient!

var gotInt = false
var gotAck = false
var gotJSON = false
var gotBool = false
var gotMult = false
var gotData = false
var gotArray = false
var gotBlank = false
var gotDouble = false
var gotString = false
var gotNested = false
var gotMultAck = false
var reconnected = false
var gotBinaryAck = false

var clientObject = NSMutableDictionary()

let data1 = "0".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
let data2 = "1".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
let data3 = "2".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
let data4 = "3".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
let data5 = "4".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
let data6 = "5".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!

let cookieProps = [
    NSHTTPCookieOriginURL: "http://localhost",
    NSHTTPCookiePath: "/",
    NSHTTPCookieName: "myCookie",
    NSHTTPCookieValue: "234"
]

let cookie = NSHTTPCookie(properties: cookieProps)!
let cookieArray = [cookie]
let headers = ["testing": "blah", "testing2": "b/:lah"]

func connectSocket() {
//    socket.connect(timeoutAfter: 1) {
//        println("failed to connect")
//    }
    socket.connect()
}

if testCytube {
    socket = SocketIOClient(socketURL: "https://cytu.be:10443", opts: [
        "forcePolling": false,
        "forceWebsockets": false,
        "log": true
        ])
} else {
    socket = SocketIOClient(socketURL: "127.0.0.1:8080", opts: [
        "reconnects": true, // default true
        "reconnectAttempts": -1, // default -1
        "reconnectWait": 5, // default 10
        "forcePolling": false,
        "forceWebsockets": false,// default false
        "nsp": "/swift",
        "log": true,
        "path": "",
        "extraHeaders": headers,
//        "connectParams": [
//            "test": 2.1,
//            "d": "{}"
//        ],
        //"cookies": cookieArray
        ])
}

socket.on("connect") {data, ack in
    print("Socket connected")
    print("sending tests")
    print(socket.sid)
    // socket.disconnect(fast: true)
    
    if !testCytube {
        
        let myJSON = [
            "name": "bob\ntracy"
        ]
        
        socket.emit("test")
        socket.emit("nullTest", NSNull())
        socket.emit("jsonTest", myJSON)
        socket.emit("stringTest", "π\ntest")
        socket.emit("multData", data1, ["world": data2])
        socket.emit("arrayTest", [1, true, "test", ["test": "test"], data1, data2])
        socket.emit("jsonTest", ["data": data1, "data2": ["data3": data2], "data4": [data3]])
        socket.emit("intTest", 1)
        socket.emit("doubleTest", 2.3)
        socket.emit("boolTest", true)
        socket.emit("dataTest", data1)
        socket.emit("nested", [data1, ["test": data2, "test2": ["test3": [data3, ["test5": data4]]]], data5])
        socket.emit("multTest", [data1], 1.4, 1, "true", 2, ["test": [data2], "null": NSNull()], data3)
        socket.emit("multTest", ["test": data1], 1.4, 1, "true", true, ["test": [data2]], data3)
        // socket.emit("closeTest")
    } else {
        // Cytube tests
        socket.emit("initChannalCallbacks")
        socket.emit("joinChannel", ["name": "fullmoviesonyoutube"])
    }
}

//socket.onAny {print("got event: \($0.event) with items \($0.items)")}


socket.on("deinit") {data, ack in
    socket.close(fast: true)
}

socket.on("disconnect") {data, ack in
    if let reason = data?[0] as? String {
        print("Socket disconnected: \(reason)")
        // socket = SocketIOClient(socketURL: "localhost:8080")
        // exit(1)
        //socket.connect()
    }
}

socket.on("error") {data, ack in
    if let err = data?[0] as? String {
        print("Got error: \(err)")
    }
}

socket.on("reconnect") {data, ack in
    print("Socket reconnecting: \(data![0])")
}

socket.on("reconnectAttempt") {data, ack in
    if let triesLeft = data?[0] as? Int {
        print("Reconnect tries left: \(triesLeft)")
        // exit(1)
    }
}

socket.on("closeTest") {data in
    print("got closeTest")
    // socket.close()
}

socket.on("nullTest") {data, ack in
    print("Got null test")
}

socket.on("blankTest") {data, ack in
    print("got blank test")
    assert(data?.count == 0, "Failed blank test: \(data)")
    gotBlank = true
}

socket.on("nestedTest") {data, ack in
    print("Got nested test")
    // println(data)
    gotNested = true
}

socket.on("multipleItems") {data, ack in
    print("Got multipleItems")
    gotMult = true
    
    // println(reflect(data![0]))
    if var arr = data?[1] as? [AnyObject] {
        arr.append(5)
        // println(arr)
    }
}

socket.on("foobar") {data, ack in
    if let json = data?[0] as? NSDictionary {
        print(json["test"]!) // foo bar
    }
}

socket.on("boolTest") {data, ack in
    if let bool = data?[0] as? Bool {
        print("got bool test")
        assert(bool == true, "Failed boolTest") // true
        gotBool = true
    }
}

socket.on("jsonTest") {data, ack in
    print("got json test")
    if var json = data?[0] as? [NSObject: AnyObject] {
        json["bob"] = "bob"
        if let str = json["foo"] as? String {
            assert(str == "string\ntest test", "Failed json test")
            gotJSON = true
        }
    } else {
        assert(false, "Failed json test")
    }
}

socket.on("stringTest") {data, ack in
    print("got string test")
    if let str = data?[0] as? String {
        assert(str == "line one\nline two", "Failed string test")
        gotString = true
    } else {
        assert(false, "failed string test")
    }
}

socket.on("arrayTest") {data, ack in
    if let array = data?[0] as? NSArray {
        print("Got array test")
        assert(array[0] as! Int == 2, "Failed arrayTest") // 2
        assert(array[1] as! String == "test", "Failed arrayTest") // "test"
        gotArray = true
    }
}

socket.on("intTest") {data, ack in
    if let intData = data?[0] as? Int {
        print("got int test")
        assert(intData == 2, "Failed intTest")
        gotInt = true
    }
}

socket.on("doubleTest") {data, ack in
    print("got double test")
    if let d = data?[0] as? Double {
        assert(d == 2.2, "Failed doubleTest")
        gotDouble = true
    } else {
        assert(false, "Failed doubleTest")
    }
}

socket.on("dataTest") {data, ack in
    if let data = data?[0] as? NSData {
        print("Got binary")
        gotData = true
    }
}

socket.on("objectDataTest") {data, ack in
    if let dict = data?[0] as? NSDictionary {
        if let data = dict["data"] as? NSData {
            let string = NSString(data: data, encoding: NSUTF8StringEncoding)
            print("Got data: \(string!)")
        }
    }
}

socket.on("mult") {data, ack in
    print("got mult")
}

socket.on("burstTest") {data, ack in
    print("got burst")
}

socket.on("ackEvent") {data, ack in
    print("Got ackEvent")
    // println(data)
    if let str = data?[0] as? String {
        assert(str == "gakgakgak", "Failed ackEvent")
        gotAck = true
    }
    
    ack?("got it", data1)
    
    socket.emitWithAck("ackack", "test", 1)(timeoutAfter: 0) {ackData in
        print("got ackack")
        if let dict = ackData?[0] as? NSDictionary {
            // println(dict)
        } else {
            if let str = ackData?[0] as? String {
                if str == "No ACK" {
                    print("The server did not ack")
                } else {
                    print(str)
                }
            } else {
                assert(ackData != nil || ackData?.count != 0, "emitWithAck failed")
            }
        }
    }
    
    socket.emitWithAck("ackack2", "test", 1)(timeoutAfter: 0) {ackData in
        print("got ackack2")
        
        if let dict = ackData?[0] as? NSDictionary {
            print(dict["data"])
        }
    }
    
}

socket.on("binaryAckEvent") {data, ack in
    print("Got binaryAckEvent")
    if let data = data?[0] as? NSData {
        let str = NSString(data: data, encoding: NSUTF8StringEncoding)! as String
        // println(data)
        // println(str)
        assert(str == "gakgakgak2", "Binary in binaryAckEvent is wrong")
        gotBinaryAck = true
        ack?(data, "Got your binary ack")
    } else {
        assert(false, "binaryAckEvent failed with data: \(data)")
    }
}

socket.on("multAckEvent") {data, ack in
    assert(data != nil, "data in multAckEvent is nil")
    print("got multiAckEvent")
    
    if let gakData = data![0] as? NSData {
        print("Got gakData in multAckEvent")
        let str = NSString(data: gakData, encoding: NSUTF8StringEncoding)! as String
        // println(gakData)
        // println(str)
        assert(str == "gakgakgak3", "Binary in multAckEvent is wrong")
        
        if let num = data![1] as? Int {
            print("Got num in multAckEvent")
            assert(num == 2, "Num != 2 in multAckEvent")
        } else {
            assert(false, "multAckEvent int != 2")
        }
    } else {
        assert(false, "multAckEvent data failure")
    }
    
    gotMultAck = true
    ack?("Got your multiack dude")
}

socket.on("nspTest") {data, ack in
    print("got nsptest")
    print(data)
}

socket.on("nspTestMult") {data, ack in
    print("got nspTestMult")
    print(data)
}

socket.on("nspMult") {data, ack in
    print("got nspmult")
    print(data)
}

socket.on("echo") {data, ack in
    print("got echo")
}

socket.on("nspLeave") {data, ack in
    socket.leaveNamespace()
}

socket.on("unicodeTest") {data, ack in
    print("got unicode test")
    if let str = data?[0] as? String {
        assert(str == "πÔÒÔ", "Failed unicodeTest")
        return
    }
    
    assert(false, "Failed unicodeTest")
}

socket.on("reconnectTest") {data, ack in
    print("trying reconnect")
    
    if !reconnected {
        socket.reconnect()
        reconnected = true
    }
}

// Cytube handlers
socket.on("chatMsg") {data, ack in
    // println("got chat msg")
    if let json = data?[0] as? NSDictionary {
        let username = json["username"] as! String
        let msg = json["msg"] as! String
        
        NSLog("\(username): \(msg)")
    }
}

socket.on("kick") {data, ack in
    print("got kicked")
}

connectSocket()

let waitTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * NSEC_PER_SEC))
dispatch_after(waitTime, dispatch_get_main_queue()) {
    //println("socket closing")
    //socket.close(fast: false)
    
    if !testCytube {
        assert(gotBinaryAck, "Failed binary ack test")
        assert(gotArray, "Failed array test")
        assert(gotAck, "Failed ack test")
        assert(gotBlank, "Failed blank test")
        assert(gotData, "Failed data test")
        assert(gotDouble, "Failed double test")
        assert(gotInt, "Failed int test")
        assert(gotNested, "Failed nested test")
        assert(gotMult, "Failed multiple test")
        assert(gotMultAck, "Failed multack test")
        assert(gotString, "Failed string test")
    }
}

CFRunLoopRun()