func (adapter *RESTfulSendChannelAdapter) SendPulseRQ(pulserq proto.Message) (proto.Message, error) { // Marshal the rq if _bytes, err := proto.Marshal(pulserq); err != nil { msg, _ := lib_gc_event.NotifyEvent("004-005", "", &[]string{adapter.url, err.Error()}) return nil, errors.New(msg) } else { lib_gc_log.Trace.Printf("ADAPTER content [%p, %s], container [%p, %s] PULSE RQ: %v+ \n", &adapter.Contents, RESTFUL_SEND_CHANNEL_ADAPTER, adapter.Container, adapter.Container.GetName(), pulserq) // build the request if request, err := http.NewRequest(adapter.method, adapter.url, bytes.NewBuffer(_bytes)); err != nil { msg, _ := lib_gc_event.NotifyEvent("004-001", "", &[]string{adapter.url, err.Error()}) return nil, errors.New(msg) } else { // Set headers request.Header.Set("Content-Type", "application/x-protobuf") request.Header.Set("Accept", "application/x-protobuf") // Set the request auth request.SetBasicAuth(adapter.user, adapter.pwd) // Do the request if response, err := adapter.http_client.Do(request); err != nil { msg, _ := lib_gc_event.NotifyEvent("004-002", "", &[]string{adapter.url, err.Error()}) return nil, errors.New(msg) } else { // Close the response body to reuse the connection. defer response.Body.Close() // Read the response if body, err := ioutil.ReadAll(response.Body); err != nil { msg, _ := lib_gc_event.NotifyEvent("004-003", "", &[]string{adapter.url, err.Error()}) return nil, errors.New(msg) } else { rs := adapter.pulse_rs_instance_getter() if err := proto.Unmarshal(body, rs); err != nil { msg, _ := lib_gc_event.NotifyEvent("004-004", "", &[]string{adapter.url, err.Error(), string(body)}) return nil, errors.New(msg) } else { lib_gc_log.Info.Printf("ADAPTER content [%p, %s], container [%p, %s] Sent %d bytes, RS [%d] received from BPulse: %v \n", &adapter.Contents, RESTFUL_SEND_CHANNEL_ADAPTER, adapter.Container, adapter.Container.GetName(), len(_bytes), response.StatusCode, rs.String()) return rs, nil } } } } } }
/* Shutdown the BPulse client Parameters: Returns The list of fired up errors if some issue has occurred at shutdown the containers. */ func ShutdownBPulseClient() *list.List { l := list.New() if status == BPULSECLIENT_NOT_STARTED { msg, _ := lib_gc_event.NotifyEvent("008-004", "", &[]string{}) l.PushBack(errors.New(msg)) } else { if err := waitForContainerShutdown(lib_bpulse_event.Container.GetGenericContainer()); err != nil { l.PushBack(err) } else { if err := waitForContainerShutdown(lib_pulse_aggregator.Container.GetGenericContainer()); err != nil { l.PushBack(err) } else { if err := waitForContainerShutdown(lib_pulse_storage.Container.GetGenericContainer()); err != nil { l.PushBack(err) } else { if err := waitForContainerShutdown(lib_pulses_sender.Container.GetGenericContainer()); err != nil { l.PushBack(err) } else { if err := waitForContainerShutdown(lib_send_channel_adapter.Container.GetGenericContainer()); err != nil { l.PushBack(err) } } } } } } return l }
func (container *genericContainer) GetParameter(key string) (interface{}, error) { if value, ok := container.parameters[key]; !ok { _msg, _ := lib_gc_event.NotifyEvent("005-002", "", &[]string{key}) return nil, errors.New(_msg) } else { return value, nil } }
func (container *genericContainer) GetItem(name string) (IGenericContents, error) { if item, ok := container.items[name]; !ok { _msg, _ := lib_gc_event.NotifyEvent("005-001", "", &[]string{name}) return nil, errors.New(_msg) } else { return item, nil } }
func (container *SendChannelAdapterContainer) takePool(name string) (lib_gc_pool.Pooler, error) { if pool, err := container.Container.GetItem(name); err != nil { _msg, _ := lib_gc_event.NotifyEvent("004-001", "", &[]string{name}) return nil, errors.New(_msg) } else { return pool.(lib_gc_pool.Pooler), nil } }
func (dps *DefaultPulseStorage) Shutdown() error { lib_gc_log.Info.Printf("STORAGE content [%p, %s], container [%p, %s] SHUTDOWN catched. \n", &dps.Contents, DEFAULT_STORAGE_NAME, dps.Container, dps.Container.GetName()) // Wait for all pulses has been sent if _, _, timeout_err := lib_gc_timeout_wrapper.TimeoutWrapper.Wrap(time.Duration(shutdown_timeout)*time.Millisecond, dps); timeout_err != nil { _msg, _ := lib_gc_event.NotifyEvent("007-001", "", &[]string{DEFAULT_STORAGE_NAME}) return errors.New(_msg) } else { return nil } }
/** This method checks if the writer (store pulses) has exceeded the reader (send pulses) on the ring */ func (dps *DefaultPulseStorage) checkForWriterReaderRelation() { exceeded := dps.count_stored-dps.count_taken >= int32(dps.ring_size) lib_gc_log.Trace.Printf("STORAGE content [%p, %s], container [%p, %s] CHECK for writer-reader relation [%d - %d] [%t] \n", &dps.Contents, DEFAULT_STORAGE_NAME, dps.Container, dps.Container.GetName(), dps.count_stored, dps.count_taken, exceeded) if exceeded { // The writer has reached the reader. msg, _ := lib_gc_event.NotifyEvent("007-002", "", &[]string{fmt.Sprint(time.Now())}) lib_gc_log.Error.Println(msg) // Normalize the counters. Skip the lost changes. dps.incTaken((dps.count_stored % int32(dps.ring_size)) * int32(dps.ring_size)) } }
func (adapter *RESTfulSendChannelAdapter) Start() error { lib_gc_log.Info.Printf("ADAPTER content [%p, %s], container [%p, %s] START catched. \n", &adapter.Contents, RESTFUL_SEND_CHANNEL_ADAPTER, adapter.Container, adapter.Container.GetName()) // Set bpulse rs instance gettter // It's necessary to unmarshal the responses f := func() { if rs_instance_getter, err := adapter.Container.(lib_gc_container.IGenericContainer).GetParameter(lib_send_channel_adapter.RS_INSTANCE_GETTER); err != nil { msg, _ := lib_gc_event.NotifyEvent("004-006", "", &[]string{}) lib_gc_log.Error.Println(msg) } else { adapter.pulse_rs_instance_getter = rs_instance_getter.(lib_send_channel_adapter.PulseRSInstanceGetter) } } adapter.once.Do(f) return nil }
func (contents *Contents) WaitForStatusChanges() { lib_gc_log.Info.Printf("Start WaitForStatusChanges on content %p, container %p [%s] \n", contents, contents.Container, contents.Container.GetName()) // Synchronize the container Start with the goroutine wg := &sync.WaitGroup{} wg.Add(1) var once sync.Once go func(contents *Contents, wg *sync.WaitGroup) { var stop bool = false // var first_loop bool = true for !stop { shutdown_chan, start_chan, stop_chan := contents.Container.GetContainerStatusChannels() lib_gc_log.Info.Printf("Check for status, content %p [status %d], conainer %p [%s], shutdown chan %p, start chan %p, stop chan %p", contents, contents.Status, contents.Container, contents.Container.GetName(), shutdown_chan, start_chan, stop_chan) // Only on the first loop, the goroutine must be synchronized with the container. If not, // the container would close its start channel before the goroutine was running and the // start event would not be catched. once.Do(wg.Done) // Catch container events. select { case <-shutdown_chan: lib_gc_log.Info.Printf("Received SHUTDOWN on content %p, container %p [%s] \n", contents, contents.Container, contents.Container.GetName()) if err := contents.Shutdown(); err != nil { _msg, _ := lib_gc_event.NotifyEvent("003-002", "", &[]string{err.Error()}) lib_gc_log.Error.Println(_msg) } stop = true case <-start_chan: lib_gc_log.Info.Printf("Received START on content %p, container %p [%s] \n", contents, contents.Container, contents.Container.GetName()) contents.Start() case <-stop_chan: lib_gc_log.Info.Printf("Received STOP on content %p, container %p [%s] \n", contents, contents.Container, contents.Container.GetName()) contents.Stop() } } }(contents, wg) wg.Wait() }
func (ev *EventLogger) Send_event(event_message *lib_bpulse_event.Event_message) error { m := map[string]interface{}{ "id": strconv.FormatInt(time.Now().UnixNano(), 10), "type": string(event_message.Type), "title": event_message.Title, "description": event_message.Description, "startDate:": event_message.StartDate, "endDate": event_message.EndDate, "source": ev.server.source, "dataSourceId": ev.server.data_source_id, "editable": ev.server.editable, } mJson, _ := json.Marshal(m) println("\n", string(mJson), "\n") var _err error tr := &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } for z := 0; z < ev.server.reentries; z++ { request := gorequest.New().Timeout(time.Duration(ev.server.timeout) * time.Millisecond) request.Transport = tr request.Header["Authorization"] = "Basic " + ev.basicAuth(ev.server.user, ev.server.user) _, body, errs := request.Post(ev.server.url). Set("Content-Type", "application/json"). Send(string(mJson)). End() println("*jas* body: ", body) if strings.Contains(body, "error") { if errs == nil { errs = []error{errors.New(body)} } else { errs = append(errs, errors.New(body)) } } if errs == nil || len(errs) == 0 { break } else { str := "" for i, s := range errs { if i > 0 { str += ", " + s.Error() } else { str = s.Error() } } msg, _ := lib_gc_event.NotifyEvent("009-001", "", &[]string{str}) lib_gc_log.Error.Println(msg) _err = errors.New(str) // Wait for the next retry timer := time.NewTimer(500 * time.Millisecond) <-timer.C } } if _err != nil { return _err } else { return nil } }
/* This method starts the Go BPulse client. Parameters: rq_maker: BPulse RQ builder from a slice of pulses rs_processor: BPulse responses writer. (optional) rs_instance_getter: BPulse RS intance getter. Returns error: The fired up error if some issue occurs. */ func StartBPulseClient(rq_maker lib_pulses_sender.PulseRQMaker, rs_processor lib_pulses_sender.PulseRSProcessor, rs_instance_getter lib_send_channel_adapter.PulseRSInstanceGetter) error { // panic catching defer lib_gc_panic_catching.PanicCatching("StartBPulseClient") if status == BPULSECLIENT_STARTED { msg, _ := lib_gc_event.NotifyEvent("008-003", "", &[]string{}) return errors.New(msg) } else { // Start the contents. lib_gc_contents_loader.InitializeContainerContents() // start event logger container if err := waitForContainerStarts(lib_bpulse_event.Container.GetGenericContainer()); err != nil { return err } else { // start storage container if err := waitForContainerStarts(lib_pulse_storage.Container.GetGenericContainer()); err != nil { return err } else { // start aggregator container if err := waitForContainerStarts(lib_pulse_aggregator.Container.GetGenericContainer()); err != nil { return err } else { // Set the bpulse rs instance getter for unmarsal bpulse respones. It's mandatory if rs_instance_getter == nil { msg, _ := lib_gc_event.NotifyEvent("008-002", "", &[]string{}) return errors.New(msg) } else { lib_send_channel_adapter.Container.GetGenericContainer().AddParameter(lib_send_channel_adapter.RS_INSTANCE_GETTER, rs_instance_getter) // start sender channel adapter container if err := waitForContainerStarts(lib_send_channel_adapter.Container.GetGenericContainer()); err != nil { return err } else { // Set the rq maker. It's mandatory. if rq_maker == nil { msg, _ := lib_gc_event.NotifyEvent("008-001", "", &[]string{}) return errors.New(msg) } else { lib_pulses_sender.Container.GetGenericContainer().AddParameter(lib_pulses_sender.PULSE_RQ_MAKER, rq_maker) // RS processor is optional. if rs_processor != nil { lib_pulses_sender.Container.GetGenericContainer().AddParameter(lib_pulses_sender.PULSE_RS_PROCESSOR, rs_processor) } if err := waitForContainerStarts(lib_pulses_sender.Container.GetGenericContainer()); err != nil { return err } } } } } } } status = BPULSECLIENT_STARTED return nil } }
func (dpa *DefaultPulseAggregator) run() { // panic catching defer func() { lib_gc_panic_catching.PanicCatching("DefaultSender.run") dpa.isrunning = false }() lib_gc_log.Info.Printf("AGGREGATOR content [%p, %s], container [%p, %s] RUN STARTED. \n", &dpa.Contents, DEFAULT_AGGREGATOR_NAME, dpa.Container, dpa.Container.GetName()) var record *lib_pulse_storage.PulseRecord var last_storage_at time.Time = time.Now() ticker := time.NewTicker(time.Nanosecond * 100) for _ = range ticker.C { if dpa.Contents.Status == lib_gc_container.CONTAINER_STATUS_STARTED && dpa.storage != nil { select { case pulse, ok := <-dpa.aggregation_channel: _ = pulse _ = ok lib_gc_log.Trace.Printf("AGGREGATOR recived pulse %p on content %p, container %p [%s] \n", pulse, &dpa.Contents, dpa.Container, dpa.Container.GetName()) lib_gc_log.Trace.Printf("AGGREGATOR recived pulse %p : %v+ \n", pulse.String()) // Check for channel keeps opened if !ok { _msg, _ := lib_gc_event.NotifyEvent("003-001", "", &[]string{}) lib_gc_log.Warning.Println(_msg) dpa.Status = lib_gc_container.CONTAINER_STATUS_STOPPED break } // Check for an active record if record == nil { key := strconv.FormatInt(time.Now().Unix(), 10) pulses := make([]proto.Message, dpa.record_size) record = &lib_pulse_storage.PulseRecord{Key: key, Pulses: pulses, Pos: 0} } // Add the pulse to the record. record.Pulses[record.Pos] = pulse lib_gc_log.Trace.Printf("AGGREGATOR added pulse %p on content %p, container %p [%s], pos %d / %d \n", pulse, &dpa.Contents, dpa.Container, dpa.Container.GetName(), record.Pos, dpa.record_size) record.Pos = record.Pos + 1 // Check if the record pulses have reached the block_size size if record.Pos == dpa.record_size { // Store lib_gc_log.Trace.Printf("AGGREGATOR storing BY BLOCK SIZE [%d - %d] pulse %p on content %p, container %p [%s] \n", record.Pos, dpa.record_size, pulse, &dpa.Contents, dpa.Container, dpa.Container.GetName()) record.Pulses = record.Pulses[:record.Pos] dpa.storage.AddPulseRecord(record) last_storage_at = time.Now() record = nil } default: delay := int64(time.Now().Sub(last_storage_at).Nanoseconds() / 1000000) if record != nil && delay >= dpa.max_time_without_store { lib_gc_log.Info.Printf("AGGREGATOR storing BY TIMING pulses on content %p, container %p [%s] with delay %s \n", &dpa.Contents, dpa.Container, dpa.Container.GetName(), fmt.Sprint(time.Now().Sub(last_storage_at))) // Store record.Pulses = record.Pulses[:record.Pos] dpa.storage.AddPulseRecord(record) last_storage_at = time.Now() record = nil } } } } }
func (ds *DefaultSender) run() { // panic catching defer func() { lib_gc_panic_catching.PanicCatching("DefaultSender.run") ds.isrunning = false }() lib_gc_log.Info.Printf("SENDER content [%p, %s], container [%p, %s] RUN STARTED.\n", &ds.Contents, DEFAULT_SENDER, ds.Container, ds.Container.GetName()) for { ds.isrunning = true if ds.Contents.Status == lib_gc_container.CONTAINER_STATUS_STARTED && ds.storage != nil { max_concurrent_records_semaphore.Lock(1) if record, err := ds.storage.GetPulseRecord(); err != nil { msg, _ := EVENT.NotifyEvent("006-001", "", &[]string{err.Error()}) lib_gc_log.Error.Printf("%s\n", msg) ds.writeToRSWriter([]byte(msg)) } else { if record != nil { lib_gc_log.Trace.Printf("SENDER content [%p, %s], container [%p, %s] Taken pulse record, with %d pulses.\n", &ds.Contents, DEFAULT_SENDER, ds.Container, ds.Container.GetName(), len(record.Pulses)) if ds.pulse_rq_maker == nil { msg, _ := EVENT.NotifyEvent("006-004", "", &[]string{DEFAULT_SENDER}) lib_gc_log.Error.Println(msg) } else { if rq, err := ds.pulse_rq_maker(record.Pulses); err != nil { msg, _ := EVENT.NotifyEvent("006-005", "", &[]string{DEFAULT_SENDER}) lib_gc_log.Error.Println(msg) } else { go func(rq proto.Message, rs_processor lib_pulses_sender.PulseRSProcessor, semaphore lib_gc_semaphore.Semaphore_I) { // panic catching defer lib_gc_panic_catching.PanicCatching("DefaultSender.run - go") if adapter, err := lib_send_channel_adapter.Container.GetSendChannelAdapter(adapter_name); err != nil { msg, _ := EVENT.NotifyEvent("006-002", "", &[]string{err.Error()}) lib_gc_log.Error.Printf("%s\n", msg) ds.writeToRSWriter([]byte(msg)) } else { defer lib_send_channel_adapter.Container.ReleaseSendChannelAdapter(adapter_name, adapter) semaphore.Lock(1) sent := false retries := 0 for (!sent) && (retries < msg_sending_reintries) { retries += 1 if rs, err := adapter.SendPulseRQ(rq); err != nil { if msg, err2 := EVENT.NotifyEvent("006-003", "", &[]string{err.Error()}); err2 == nil { lib_gc_log.Error.Printf("%s \n !!", msg) ds.writeToRSWriter([]byte(msg)) } else { lib_gc_log.Error.Printf("%s \n !!", err2.Error()) ds.writeToRSWriter([]byte(msg)) } } else { sent = true if rs_processor != nil { if err := rs_processor(rs, ds.rs_writer); err != nil { ds.writeToRSWriter([]byte(err.Error())) } } } } semaphore.ForceToUnLock(1) } }(rq, ds.pulse_rs_processor, max_concurrent_sents_semaphore) } } } } max_concurrent_records_semaphore.ForceToUnLock(1) } } }