func TestClientNameToCertificate(t *testing.T) {
certificate, _ := certificate.FromP12File("certificate/_fixtures/certificate-valid.p12", "")
client := apns.NewClient(certificate)
name := client.HTTPClient.Transport.(*http2.Transport).TLSClientConfig.NameToCertificate
assert.Len(t, name, 1)
certificate2 := tls.Certificate{}
client2 := apns.NewClient(certificate2)
name2 := client2.HTTPClient.Transport.(*http2.Transport).TLSClientConfig.NameToCertificate
assert.Len(t, name2, 0)
}
func Start() {
LogInfo("Push proxy server is initializing...")
if len(CfgPP.ApplePushCertPrivate) > 0 {
appleCert, appleCertErr := certificate.FromPemFile(CfgPP.ApplePushCertPrivate, CfgPP.ApplePushCertPassword)
if appleCertErr != nil {
LogCritical(fmt.Sprintf("Failed to load the apple pem cert err=%v", appleCertErr))
}
if CfgPP.ApplePushUseDevelopment {
appleClient = apns.NewClient(appleCert).Development()
} else {
appleClient = apns.NewClient(appleCert).Production()
}
} else {
LogError("Apple push notifications not configured. Mssing ApplePushCertPrivate.")
}
if len(CfgPP.AndroidApiKey) == 0 {
LogError("Android push notifications not configured. Mssing AndroidApiKey.")
}
router := mux.NewRouter()
var handler http.Handler = router
vary := throttled.VaryBy{}
vary.RemoteAddr = false
vary.Headers = strings.Fields(CfgPP.ThrottleVaryByHeader)
th := throttled.RateLimit(throttled.PerSec(CfgPP.ThrottlePerSec), &vary, throttledStore.NewMemStore(CfgPP.ThrottleMemoryStoreSize))
th.DeniedHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
LogError(fmt.Sprintf("%v: code=429 ip=%v", r.URL.Path, GetIpAddress(r)))
throttled.DefaultDeniedHandler.ServeHTTP(w, r)
})
handler = th.Throttle(router)
router.HandleFunc("/", root).Methods("GET")
r := router.PathPrefix("/api/v1").Subrouter()
r.HandleFunc("/send_push", handleSendNotification).Methods("POST")
go func() {
err := manners.ListenAndServe(CfgPP.ListenAddress, handler)
if err != nil {
LogCritical(err.Error())
}
}()
LogInfo("Server is listening on " + CfgPP.ListenAddress)
}
func main() {
cert, err := certificate.FromP12File("../cert.p12", "")
if err != nil {
log.Fatal("Cert Error:", err)
}
notification := &apns2.Notification{}
notification.DeviceToken = "11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef7"
notification.Topic = "com.sideshow.Apns2"
notification.Payload = []byte(`{
"aps" : {
"alert" : "Hello!"
}
}
`)
client := apns2.NewClient(cert).Production()
res, err := client.Push(notification)
if err != nil {
log.Fatal("Error:", err)
}
fmt.Printf("%v %v %v\n", res.StatusCode, res.ApnsID, res.Reason)
}
func main() {
cert, pemErr := certificate.FromPemFile("../cert.pem", "")
if pemErr != nil {
log.Println("Cert Error:", pemErr)
}
notification := &apns.Notification{}
notification.DeviceToken = "11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef7"
notification.Topic = "com.sideshow.Apns2"
notification.Payload = []byte(`{
"aps" : {
"alert" : "Hello!"
}
}
`)
client := apns.NewClient(cert).Development()
res, err := client.Push(notification)
if err != nil {
log.Println("Error:", err)
return
}
log.Println("APNs ID:", res.ApnsID)
}
func TestClientManagerAddWithoutNew(t *testing.T) {
manager := apns2.ClientManager{
MaxSize: 32,
MaxAge: 5 * time.Minute,
Factory: apns2.NewClient,
}
manager.Add(apns2.NewClient(mockCert()))
assert.Equal(t, 1, manager.Len())
}
func TestClientManagerAdd(t *testing.T) {
fn := func(certificate tls.Certificate) *apns2.Client {
t.Fatal("factory should not have been called")
return nil
}
manager := apns2.NewClientManager()
manager.Factory = fn
manager.Add(apns2.NewClient(mockCert()))
manager.Get(mockCert())
}
func newPusher(c Config) (Pusher, error) {
var (
cert tls.Certificate
errCert error
)
if c.CertificateFileName != nil && *c.CertificateFileName != "" {
cert, errCert = certificate.FromP12File(*c.CertificateFileName, *c.CertificatePassword)
} else {
cert, errCert = certificate.FromP12Bytes(*c.CertificateBytes, *c.CertificatePassword)
}
if errCert != nil {
return nil, errCert
}
if *c.Production {
logger.Debug("APNS Pusher in Production mode")
return apns2.NewClient(cert).Production(), nil
}
logger.Debug("APNS Pusher in Development mode")
return apns2.NewClient(cert).Development(), nil
}
func TestClientManagerGetMaxAgeExpirationWithNilFactory(t *testing.T) {
manager := apns2.NewClientManager()
manager.Factory = func(certificate tls.Certificate) *apns2.Client {
return nil
}
manager.MaxAge = time.Nanosecond
manager.Add(apns2.NewClient(mockCert()))
c1 := manager.Get(mockCert())
time.Sleep(time.Microsecond)
c2 := manager.Get(mockCert())
assert.Nil(t, c1)
assert.Nil(t, c2)
assert.Equal(t, 1, manager.Len())
}
func main() {
kingpin.UsageTemplate(kingpin.CompactUsageTemplate).Version("0.1").Author("Alisson Sales")
kingpin.CommandLine.Help = `Listens to STDIN to send nofitications and writes APNS response code and reason to STDOUT.
The expected format is: <DeviceToken> <APNS Payload>
Example: aff0c63d9eaa63ad161bafee732d5bc2c31f66d552054718ff19ce314371e5d0 {"aps": {"alert": "hi"}}`
kingpin.Parse()
cert, pemErr := certificate.FromPemFile(*certificatePath, "")
if pemErr != nil {
log.Fatalf("Error retrieving certificate `%v`: %v", certificatePath, pemErr)
}
client := apns2.NewClient(cert)
if *mode == "development" {
client.Development()
} else {
client.Production()
}
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
in := scanner.Text()
notificationArgs := strings.SplitN(in, " ", 2)
token := notificationArgs[0]
payload := notificationArgs[1]
notification := &apns2.Notification{
DeviceToken: token,
Topic: *topic,
Payload: payload,
}
res, err := client.Push(notification)
if err != nil {
log.Fatal("Error: ", err)
} else {
fmt.Printf("%v: '%v'\n", res.StatusCode, res.Reason)
}
}
}
func TestDialTLSTimeout(t *testing.T) {
apns.TLSDialTimeout = 1 * time.Millisecond
certificate, _ := certificate.FromP12File("certificate/_fixtures/certificate-valid.p12", "")
client := apns.NewClient(certificate)
dialTLS := client.HTTPClient.Transport.(*http2.Transport).DialTLS
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
address := listener.Addr().String()
defer listener.Close()
var e error
if _, e = dialTLS("tcp", address, nil); e == nil {
t.Fatal("Dial completed successfully")
}
if !strings.Contains(e.Error(), "timed out") {
t.Errorf("resulting error not a timeout: %s", e)
}
}
/**
* An APN Worker which reads from RabbitMQ queue and sends APN messages
* If APN is expired or invalid it sends APN key to a queue which is processed by another goroutine and updated in database
*/
func apn_processor(identity int, config Configuration, conn *amqp.Connection,
ApnStatusInactiveQueueName, ApnQueueName string, ch_err, ch_apn_log_success chan []byte, logger *log.Logger,
killWorker chan int, apnQueue ApnQueue) {
isHourly := apnQueue.IsHourly
pemPath := apnQueue.PemPath
apnTopic := apnQueue.Topic
// Load PEM file specified in config file required to send APN messages
cert, pemErr := certificate.FromPemFile(pemPath, "")
failOnError(pemErr, "Failed to load PEM file for APN")
ApnQueueNameOriginal := ApnQueueName
now := time.Now()
var hourlyTick <-chan time.Time
if isHourly == true {
curHour := ""
curHour = strconv.Itoa(now.Hour())
curHourInt := now.Hour()
if curHourInt < 10 {
curHour = "0" + strconv.Itoa(curHourInt)
} else {
curHour = strconv.Itoa(curHourInt)
}
//tmp := now.Second()%24
//if tmp < 10 {
// curHour = "0" + strconv.Itoa(tmp)
//} else {
// curHour = strconv.Itoa(tmp)
//}
ApnQueueName = ApnQueueNameOriginal + "_" + curHour
waitTime := 60 - now.Minute()
hourlyTick = time.After(time.Duration(waitTime*61) * time.Second)
//fmt.Println(waitTime%24)
//hourlyTick = time.After(time.Duration(waitTime%24) * time.Second)
olog(fmt.Sprintf("Connecting to "+ApnQueueName), config.DebugMode)
}
// Create a new APN Client
client := apns.NewClient(cert).Production()
// Create new channel to communicate with RabbitMQ
ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer ch.Close()
err = ch.Qos(
1, // prefetch count
0, // prefetch size
false, // global
)
failOnError(err, "Failed to set QoS")
msgsApn, err := ch.Consume(
ApnQueueName, // queue
"", // consumer
false, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
failOnError(err, "Failed to register a consumer")
// Get a message
// Process it
// If processing is complete, then delete it
for {
select {
case <-hourlyTick:
olog(fmt.Sprintf("Ticking"), config.DebugMode)
curHour := ""
now = time.Now()
curHourInt := now.Hour()
if curHourInt < 10 {
curHour = "0" + strconv.Itoa(curHourInt)
} else {
curHour = strconv.Itoa(curHourInt)
}
ch.Cancel(ApnQueueName, false)
curHour = strconv.Itoa(now.Hour())
ApnQueueName = ApnQueueNameOriginal + "_" + curHour
msgsApn, err = ch.Consume(
ApnQueueName, // queue
"", // consumer
false, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
failOnError(err, "Failed to register a consumer")
olog(fmt.Sprintf("Connected to "+ApnQueueName), config.DebugMode)
waitTime := 60 - now.Minute()
hourlyTick = time.After(time.Duration(waitTime*61) * time.Second)
case <-killWorker:
// If a message is receieved through killWorker then log and exit
olog(fmt.Sprintf("%d Received kill command", identity), config.DebugMode)
return
case d, ok := <-msgsApn:
// Receieve messages from RabbitMQ,
if !ok {
// If channel is closed then wait for it to be reconnected or wait for kill signal
time.Sleep(100 * time.Millisecond)
continue
}
olog(fmt.Sprintf("%d Worker Received a message: %s", identity, d.Body), config.DebugMode)
// Receive APN message from channel and decode it
payload := ApnMessage{}
err := json.Unmarshal(d.Body, &payload)
// In case message coult not be decoded log error and skip
if err != nil {
logger.Printf("Unmarshal error = %s, for MQ message data = %s", err.Error(), d.Body)
olog(fmt.Sprintf("Unmarshal error = %s, for MQ message data = %s", err.Error(), d.Body), config.DebugMode)
// Acknowledge to MQ that work has been processed successfully
d.Ack(false)
continue
}
// Extract Body and Token from Payload
data := payload.Body
token := payload.Token
// Create new APN notification
notification := &apns.Notification{}
// Add device token
notification.DeviceToken = token
notification.Topic = apnTopic
notification.Payload, err = json.Marshal(data)
// If config contains time to love for message then add it
if apnQueue.TtlSeconds > 0 {
notification.Expiration = time.Now().Add(time.Duration(apnQueue.TtlSeconds) * time.Second)
}
// If json data contains ttl value then override it
if payload.TimeToLiveSeconds > 0 {
notification.Expiration = time.Now().Add(time.Duration(payload.TimeToLiveSeconds) * time.Second)
}
// Could not encode map to json.
if err != nil {
logger.Printf("Marshal error = %s, for MQ message data = %s", err.Error(), d.Body)
olog(fmt.Sprintf("Marshal error = %s, for MQ message data = %s", err.Error(), d.Body), config.DebugMode)
d.Ack(false)
continue
}
res, err := client.Push(notification)
if err != nil {
// gcmErrCount++
notificationByteArray, _ := json.Marshal(notification)
logger.Printf("APN send error = %s, data=%s", err.Error(), notificationByteArray)
olog(fmt.Sprintf("APN send error = %s", err.Error()), config.DebugMode)
// In case of APN error / Requeue and continue to next
// TODO: Inform admin
// Same error continues without break for 10 times, sleep for a minute
// TODO: Implement this in a better way
// if gcmErrCount >= 10 {
// time.Sleep(time.Minute)
// }
key := token
val, ok := retries_apn.Get(key)
var valint int
if ok {
valint, ok = val.(int)
if ok {
valint = valint + 1
} else {
// Log error (This should not happen) and continue
logger.Printf("APN Could not convert interface to int = %v", val)
olog(fmt.Sprintf("APN Could not convert interface to int = %v", val), config.DebugMode)
d.Ack(false)
continue
}
} else {
valint = 1
}
// If already tried 5 times, then do not requeue
if valint >= config.APN.RequeueCount+1 {
// Log it and continue
logger.Printf("Max Retries APN send data=%s", notificationByteArray)
olog(fmt.Sprintf("Max Retries APN send error. Data = %s", notificationByteArray), config.DebugMode)
retries_apn.Remove(key)
d.Ack(false)
continue
}
retries_apn.Set(key, valint)
d.Nack(false, true)
continue
} else {
// gcmErrCount = 0
// TODO: Implement this as proper goroutine, its dangereous if user exists before this goroutine ends
// Running result processor as a goroutine so that current worker can proceed with sending another APN request to
// server, without getting delayed by processing
go func() {
isSentToClientSuccesfully := StatusErrApnError
t := time.Now()
ts := t.Format(time.RFC3339)
if res.StatusCode == 200 {
// Success (Log to file at bottom)
isSentToClientSuccesfully = StatusSuccessApnRequest
} else if res.Reason == "BadDeviceToken" || res.Reason == "Unregistered" {
// Token error, set status of this token as inactive in database
// Create a Status Inactive Message to be sent to RabbitMQ queue
statusInactiveMsg := ApnStatusInactiveMsg{Token: token}
// Convert it into json byte array
jsonStatusInactiveMsg, err := json.Marshal(statusInactiveMsg)
// If there is an issue while conversion, log it and skip
if err != nil {
logger.Printf("APN status inactive Marshal error = %s", err.Error())
olog(fmt.Sprintf("APN status inactive Marshal error = %s", err.Error()), config.DebugMode)
} else {
// Publish message to RabbitMQ
err = ch.Publish(
"", // exchange
ApnStatusInactiveQueueName, // routing key
false, // mandatory
false,
amqp.Publishing{
DeliveryMode: amqp.Persistent,
ContentType: "text/json",
Body: jsonStatusInactiveMsg,
})
// If there is error while publishing message log it
if err != nil {
logger.Printf("APN status inactive Publish error = %s", err.Error())
olog(fmt.Sprintf("APN status inactive Publish error = %s", err.Error()), config.DebugMode)
}
}
// Error is logged automatically after this block
} else if res.Reason == "TooManyRequests" {
// TODO: Delay sending instead of skipping
// Error is logged automatically after this block
}
apnLog, err := json.Marshal(ApnLog{TimeStamp: ts, Type: isSentToClientSuccesfully, ApnId: token, Data: ApnError{Reason: res.Reason}})
if err != nil {
logger.Printf("Marshal error while logging APN response = %s", err.Error())
olog(fmt.Sprintf("Marshal error while logging APN response = %s", err.Error()), config.DebugMode)
}
if isSentToClientSuccesfully == StatusSuccessApnRequest {
ch_apn_log_success <- apnLog
} else {
ch_err <- apnLog
}
}()
}
// Acknowledge to MQ that work has been processed successfully
d.Ack(false)
}
}
}
func TestClientManagerAddTwice(t *testing.T) {
manager := apns2.NewClientManager()
manager.Add(apns2.NewClient(mockCert()))
manager.Add(apns2.NewClient(mockCert()))
assert.Equal(t, 1, manager.Len())
}
Log.Errorc(func() string {
return err.Error()
})
return
}
token := args[0]
msg_json := args[1]
notification := &apns.Notification{}
notification.DeviceToken = token
notification.Topic = APNsTopic
notification.Payload = []byte(msg_json)
client := apns.NewClient(Cert).Production()
res, err := client.Push(notification)
if err != nil {
Log.Errorc(func() string {
return fmt.Sprintf("(%s) push apn message failed. err: %s, res: %s", this.cid(), err, res)
})
if res.StatusCode < 500 && res.StatusCode >= 400 {
mutex.Lock()
ApnInvalidTokens = append(ApnInvalidTokens, token)
mutex.Unlock()
}
}
return
func TestClientProductionHost(t *testing.T) {
client := apns.NewClient(mockCert()).Production()
assert.Equal(t, "https://api.push.apple.com", client.Host)
}
func TestClientDevelopmentHost(t *testing.T) {
client := apns.NewClient(mockCert()).Development()
assert.Equal(t, "https://api.development.push.apple.com", client.Host)
}