func main() { scamp.Initialize("/etc/GTSOA/soa.conf") var wg sync.WaitGroup for j := 0; j < 1; j++ { wg.Add(1) go func() { client, err := scamp.Dial("0.0.0.0:63531") if err != nil { scamp.Error.Printf("could not dial service: `%s`", err) return } for i := 0; i < 1; i++ { reqId := i + 1 wg.Add(1) go func() { msg := scamp.NewRequestMessage() msg.SetAction("verify") msg.SetRequestId(reqId) scamp.Info.Printf("reqId: %d", reqId) var req SqrtRequest req.Input = rand.NormFloat64() expSqrt := math.Sqrt(req.Input) var expResp SqrtResponse if math.IsNaN(expSqrt) { expResp.NaN = true } else { expResp.Output = expSqrt } expBytes, err := json.Marshal(expResp) if err != nil { scamp.Info.Printf("could not marshal exp resp: `%s`", err) return } msg.WriteJson(req) respChan, err := client.Send(msg) if err != nil { scamp.Error.Printf("could not send message: `%s`", err) } resp := <-respChan if !bytes.HasPrefix(resp.Bytes(), expBytes) { scamp.Error.Printf("response did not match: got `%s`, expected `%s`", string(resp.Bytes()), string(expBytes)) os.Exit(1) } // scamp.Info.Printf("resp: %s", resp.Bytes()) wg.Done() }() } wg.Done() }() } wg.Wait() }
func main() { scamp.Initialize("/etc/GTSOA/soa.conf") svc, err := scamp.NewService("0.0.0.0:63531", "service_verifier") if err != nil { scamp.Error.Printf("could not create service: `%s`", err.Error()) os.Exit(1) } var reqCnt uint64 = 0 go func() { for { reqLcl := atomic.LoadUint64(&reqCnt) scamp.Info.Printf("cnt: %d", reqLcl) time.Sleep(time.Duration(10) * time.Second) } }() // svc.Register("sqrt", func(msg *scamp.Message, client *scamp.Client) { // atomic.AddUint64(&reqCnt,1) // var sqrtReq SqrtRequest // err = json.NewDecoder(bytes.NewReader(msg.Bytes())).Decode(&sqrtReq) // if err != nil { // scamp.Error.Printf("nooo: `%s`", err) // return // } // // scamp.Info.Printf("sqrt req: %s", sqrtReq) // var sqrtResp SqrtResponse // res := math.Sqrt(sqrtReq.Input) // if math.IsNaN(res) { // sqrtResp.NaN = true // } else { // sqrtResp.Output = res // } // var buf bytes.Buffer // err = json.NewEncoder(&buf).Encode(sqrtResp) // if err != nil { // scamp.Error.Printf("nooo: `%s`", err) // return // } // resp := scamp.NewResponseMessage() // resp.SetRequestId(msg.RequestId) // resp.Write(buf.Bytes()) // _,err = client.Send(resp) // if err != nil { // panic(err.Error()) // } // }) svc.Run() }
func main() { var err error var ok bool gtConfigPathPtr := flag.String("config", "/backplane/discovery/discovery", "path to the discovery file") discoveryPathOverride := flag.String("discovery-path", "", "override configured discovery path (useful for testing)") inventoryPath := flag.String("expected-inventory", "", "config file specifying which actions and in what quantity are expected") scanWaitPtr := flag.Int("wait", 10, "how long to wait between action scans") pagerdutyKeyPtr := flag.String("pagerduty-key-path", "/etc/PagerDutyServiceKey", "location of the api key for pagerduty") modePtr := flag.String("mode", "watch", "one of 'watch' or 'dump-inventory'") flag.Parse() err = scamp.Initialize(*gtConfigPathPtr) if err != nil { fmt.Printf("could not initialize scamp: `%s`\n", err) return } if *inventoryPath == "" { fmt.Printf("must provide expected-inventory path") return } var discoveryPath string if *discoveryPathOverride != "" { discoveryPath = *discoveryPathOverride } else { discoveryPath, ok = scamp.DefaultConfig().Get("discovery.cache_path") if !ok { fmt.Printf("config is missing `discovery.cache_path`\n") return } } if *modePtr == "watch" { err = doWatch(*inventoryPath, discoveryPath, *scanWaitPtr, *pagerdutyKeyPtr) } else if *modePtr == "dump-inventory" { err = doDump(*inventoryPath, discoveryPath) if err != nil { fmt.Println("failed to dump inventory:", err.Error()) os.Exit(1) } fmt.Println("data successfully written") } else { fmt.Println("unsupported mode ", *modePtr) os.Exit(1) } if err != nil { scamp.Error.Printf("failed: `%s`", err) } }
func (sip *SCAMPInputPlugin) Init(config interface{}) (err error) { scamp.Initialize(scamp.DefaultConfigPath) sip.conf = config.(*SCAMPInputPluginConfig) if len(sip.conf.Handlers) < 1 { err = errors.New("must provide at least 1 handler") return } return }
func (sop *SCAMPOutputPlugin) Init(config interface{}) (err error) { scamp.Initialize(scamp.DefaultConfigPath) sop.conf = config.(*SCAMPOutputPluginConfig) scamp.Info.Printf("Connecting to %s\n", sop.conf.Service) sop.client, err = scamp.Dial(sop.conf.Service) if err != nil { return } return }
func main() { scamp.Initialize() flag.StringVar(&announcePath, "announcepath", "", "payload to be signed") flag.StringVar(&certPath, "certpath", "", "path to cert used for signing") flag.StringVar(&keyPath, "keypath", "", "path to service private key") flag.Parse() if len(keyPath) == 0 || len(announcePath) == 0 || len(certPath) == 0 { fmt.Println("must provide all 3: certpath, keypath, and announcepath") return } keyRawBytes, err := ioutil.ReadFile(keyPath) if err != nil { scamp.Error.Fatalf("could not read key at %s", keyPath) } block, _ := pem.Decode(keyRawBytes) if block == nil { scamp.Error.Fatalf("could not decode key data (%s)", block.Type) return } else if block.Type != "RSA PRIVATE KEY" { scamp.Error.Fatalf("expected key type 'RSA PRIVATE KEY' but got '%s'", block.Type) } privKey, err := x509.ParsePKCS1PrivateKey(block.Bytes) if err != nil { scamp.Error.Fatalf("could not parse key from %s (%s)", keyPath, block.Type) } announceData, err := ioutil.ReadFile(announcePath) if err != nil { scamp.Error.Fatalf("could not read announce data from %s", announcePath) } announceSig, err := scamp.SignSHA256([]byte(announceData), privKey) if err != nil { scamp.Error.Fatalf("could not sign announce data: %s", err) } certData, err := ioutil.ReadFile(certPath) if err != nil { scamp.Error.Fatalf("could not read cert from %s", certPath) } fmt.Printf("\n%%%%%%\n%s\n%s\n%s", announceData, certData, announceSig) scamp.Trace.Printf("cool announceSig: %s", announceSig) }
func main() { scamp.Initialize("/etc/SCAMP/soa.conf") var err error multicastPacketConn, err := scamp.LocalMulticastPacketConn() if err != nil { scamp.Error.Printf("could not create local multicast packet connection") return } for { if _, err := multicastPacketConn.WriteTo([]byte("hello, world\n"), nil, scampAnnounceDest); err != nil { scamp.Trace.Printf("failed to write to multicast group: `%s`", err) break } scamp.Trace.Printf("wrote hello world to group `%s`", scampAnnounceDest) time.Sleep(5 * time.Second) } }
func main() { scamp.Initialize() service, err := scamp.NewService(":30100", "helloworld") if err != nil { scamp.Error.Fatalf("error creating new service: `%s`", err) } service.Register("helloworld.hello", func(message *scamp.Message, client *scamp.Client) { scamp.Info.Printf("go message: `%s`", message.Bytes()) blob := message.Bytes() if len(blob) > 0 { scamp.Info.Printf("helloworld had data: %s", blob) } else { scamp.Trace.Printf("helloworld was called without data") } reply := &scamp.Message{MessageType: scamp.MESSAGE_TYPE_REPLY} reply.Write(famous_words) reply.SetRequestId(message.RequestId) _, err := client.Send(reply) if err != nil { scamp.Error.Printf("error while sending reply: `%s`. continuing.", err) return } }) announcer, err := scamp.NewDiscoveryAnnouncer() if err != nil { scamp.Error.Printf("failed to create announcer: `%s`", err) return } announcer.Track(service) go announcer.AnnounceLoop() service.Run() }
func main() { scamp.Initialize() conn, err := scamp.Connect("127.0.0.1:30101") defer conn.Close() if err != nil { scamp.Error.Fatalf("could not connect! `%s`\n", err) } var sess *scamp.Session inflight := make(chan bool, 500) for { inflight <- true go func() { sess, err = conn.Send(scamp.Request{ Action: "helloworld.hello", EnvelopeFormat: scamp.ENVELOPE_JSON, Version: 1, }) if err != nil { scamp.Error.Fatalf("error initiating session: `%s`", err) } reply, err := sess.RecvReply() if err != nil { scamp.Error.Fatalf("error receiving: `%s`", err) } scamp.Info.Printf("Got reply! `%s`", reply.Blob) <-inflight }() } }
func main() { scamp.Initialize() var clients []*scamp.Client = make([]*scamp.Client, 10000) var wg sync.WaitGroup for i := range clients { client, err := scamp.Dial("127.0.0.1:30100") if err != nil { scamp.Error.Fatalf("could not connect! `%s`\n", err) return } clients[i] = client wg.Add(1) go hitService(client, wg) } scamp.Info.Printf("waiting for stress to finish") wg.Wait() scamp.Info.Printf("done with stress") }
func main() { gtConfigPathPtr := flag.String("config", "/backplane/discovery/discovery", "path to the discovery file") flag.StringVar(&announcePath, "announcepath", "", "payload to be signed") flag.StringVar(&certPath, "certpath", "", "path to cert used for signing") flag.StringVar(&keyPath, "keypath", "", "path to service private key") flag.StringVar(&fingerprintPath, "fingerprintpath", "", "path to cert to fingerprint") flag.Parse() scamp.Initialize(*gtConfigPathPtr) if (len(keyPath) == 0 || len(announcePath) == 0 || len(certPath) == 0) && (len(fingerprintPath) == 0) { fmt.Printf("fingerprintpath: %s", fingerprintPath) fmt.Println("not enough options specified\nmust provide\n\tcertpath, keypath, and announcepath\nOR\n\tfingerprintpath") return } if len(keyPath) != 0 { doFakeDiscoveryCache() } else { doCertFingerprint() } }
func main() { scamp.Initialize("/etc/SCAMP/soa.conf") scamp.NewConfig() }
func TestMain(m *testing.M) { flag.Parse() scamp.Initialize("/etc/SCAMP/soa.conf") os.Exit(m.Run()) }