func (c RecentCacheUpdater) Update(db *DB) *json.RawMessage {
users, err := db.RecentlyUpdatedUsers(12)
if err != nil {
return nil
}
items := make([]recentItem, len(users))
for index, user := range users {
logs, err := db.ClimbingLogs(user.ID)
if err != nil {
continue
}
routeIDs := make([]bson.ObjectId, 0)
for _, log := range logs {
if !log.Pending {
routeIDs = append(routeIDs, log.Route)
}
}
items[index] = recentItem{UserID: user.ID, RouteIDs: routeIDs}
}
ret, err := json.Marshal(items)
if err != nil {
fmt.Println(err)
return nil
}
j := new(json.RawMessage)
j.UnmarshalJSON(ret)
return j
}
// MockSession creates a new mocked API session returning the JSON message stored in message.
func MockSession(message []byte) (*Session, error) {
rm := json.RawMessage{}
err := rm.UnmarshalJSON(message)
if err != nil {
return nil, err
}
return &Session{
requester: &mockRequester{message: &rm},
}, nil
}
func unmarshalRawJson(input *json.RawMessage, output interface{}) (err error) {
raw, err := input.MarshalJSON()
if err != nil {
return
}
err = json.Unmarshal(raw, &output)
if err != nil {
return
}
return
}
func (c RoutesCacheUpdater) Update(db *DB) *json.RawMessage {
routes, err := db.Routes()
if err != nil {
fmt.Println(err)
return nil
}
ret, err := json.Marshal(routes)
if err != nil {
fmt.Println(err)
return nil
}
j := new(json.RawMessage)
j.UnmarshalJSON(ret)
return j
}
func (c UsersCacheUpdater) Update(db *DB) *json.RawMessage {
users, err := db.Users()
if err != nil {
fmt.Println(err)
return nil
}
ret, err := json.Marshal(users)
if err != nil {
fmt.Println(err)
return nil
}
j := new(json.RawMessage)
j.UnmarshalJSON(ret)
return j
}
func (ts SignedTimestamp) ToSigned() (*Signed, error) {
s, err := cjson.Marshal(ts.Signed)
if err != nil {
return nil, err
}
signed := json.RawMessage{}
err = signed.UnmarshalJSON(s)
if err != nil {
return nil, err
}
sigs := make([]Signature, len(ts.Signatures))
copy(sigs, ts.Signatures)
return &Signed{
Signatures: sigs,
Signed: signed,
}, nil
}
func (sp SignedSnapshot) ToSigned() (*Signed, error) {
s, err := cjson.Marshal(sp.Signed)
if err != nil {
return nil, err
}
signed := json.RawMessage{}
err = signed.UnmarshalJSON(s)
if err != nil {
return nil, err
}
sigs := make([]Signature, len(sp.Signatures))
copy(sigs, sp.Signatures)
return &Signed{
Signatures: sigs,
Signed: signed,
}, nil
}
func (h *H) PayloadOptions(w http.ResponseWriter, req *http.Request) {
p := req.URL.Query().Get("payload")
if p == "" {
h.JSON400(w, errors.New("payload query parameter missing"))
return
}
var options [][]string
var thing json.RawMessage
err := h.C.Call("payload_options", []string{p}, &thing)
if err != nil {
h.JSON400(w, err)
return
}
d, err := thing.MarshalJSON()
if err != nil {
h.JSON400(w, err)
}
if err := json.Unmarshal(d, &options); err != nil {
h.JSON400(w, err)
return
}
opts := []PayloadOption{}
for _, o := range options {
if len(o) < 3 {
continue
}
opts = append(opts, PayloadOption{Key: o[0], DefaultValue: o[1], Value: o[2]})
}
opts = append(opts, PayloadOption{
Key: "pwnstaller",
DefaultValue: "N",
Value: "Use pwnstaller",
})
opts = append(opts, PayloadOption{
Key: "outputbase",
DefaultValue: "",
Value: "Output base for generated payloads",
})
opts = append(opts, PayloadOption{
Key: "overwrite",
DefaultValue: "true",
Value: "Overwrite existing files",
})
h.JSON(w, opts)
}
func (esi *MockIndex) PostData(typeName string, id string, obj interface{}) (*IndexResponse, error) {
ok, err := esi.IndexExists()
if err != nil {
return nil, err
}
if !ok {
return nil, fmt.Errorf("Index does not exist")
}
ok, err = esi.TypeExists(typeName)
if err != nil {
return nil, err
}
var typ *MockIndexType
if !ok {
typ = &MockIndexType{}
typ.items = make(map[string]*json.RawMessage)
esi.types[typeName] = typ
} else {
typ = esi.types[typeName]
}
byts, err := json.Marshal(obj)
if err != nil {
return nil, err
}
var raw json.RawMessage
err = raw.UnmarshalJSON(byts)
if err != nil {
return nil, err
}
typ.items[id] = &raw
r := &IndexResponse{Created: true, ID: id, Index: esi.name, Type: typeName}
return r, nil
}
// RPC Handler passes on a JSON or form encoded RPC request to
// a service.
func RPC(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
defer r.Body.Close()
badRequest := func(description string) {
e := errors.BadRequest("go.micro.rpc", description)
w.WriteHeader(400)
w.Write([]byte(e.Error()))
}
var service, method, address string
var request interface{}
// response content type
w.Header().Set("Content-Type", "application/json")
ct := r.Header.Get("Content-Type")
// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
if idx := strings.IndexRune(ct, ';'); idx >= 0 {
ct = ct[:idx]
}
switch ct {
case "application/json":
var rpcReq rpcRequest
d := json.NewDecoder(r.Body)
d.UseNumber()
if err := d.Decode(&rpcReq); err != nil {
badRequest(err.Error())
return
}
service = rpcReq.Service
method = rpcReq.Method
address = rpcReq.Address
request = rpcReq.Request
// JSON as string
if req, ok := rpcReq.Request.(string); ok {
d := json.NewDecoder(strings.NewReader(req))
d.UseNumber()
if err := d.Decode(&request); err != nil {
badRequest("error decoding request string: " + err.Error())
return
}
}
default:
r.ParseForm()
service = r.Form.Get("service")
method = r.Form.Get("method")
address = r.Form.Get("address")
d := json.NewDecoder(strings.NewReader(r.Form.Get("request")))
d.UseNumber()
if err := d.Decode(&request); err != nil {
badRequest("error decoding request string: " + err.Error())
return
}
}
if len(service) == 0 {
badRequest("invalid service")
return
}
if len(method) == 0 {
badRequest("invalid method")
return
}
// create request/response
var response json.RawMessage
var err error
req := (*cmd.DefaultOptions().Client).NewJsonRequest(service, method, request)
// create context
ctx := helper.RequestToContext(r)
// remote call
if len(address) > 0 {
err = (*cmd.DefaultOptions().Client).CallRemote(ctx, address, req, &response)
} else {
err = (*cmd.DefaultOptions().Client).Call(ctx, req, &response)
}
if err != nil {
ce := errors.Parse(err.Error())
switch ce.Code {
case 0:
// assuming it's totally screwed
ce.Code = 500
ce.Id = "go.micro.rpc"
ce.Status = http.StatusText(500)
ce.Detail = "error during request: " + ce.Detail
w.WriteHeader(500)
default:
w.WriteHeader(int(ce.Code))
}
w.Write([]byte(ce.Error()))
return
}
b, _ := response.MarshalJSON()
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
w.Write(b)
}
// RPCX Handler is an alternative handler which passes through an RPC request without modification
func (h *rpcxHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
defer r.Body.Close()
// get service/method
service, method := pathToReceiver(h.Namespace, r.URL.Path)
ct := r.Header.Get("Content-Type")
// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
if idx := strings.IndexRune(ct, ';'); idx >= 0 {
ct = ct[:idx]
}
switch ct {
case "application/json":
// response content type
w.Header().Set("Content-Type", "application/json")
// get request
br, err := ioutil.ReadAll(r.Body)
if err != nil {
e := errors.InternalServerError("go.micro.api", err.Error())
http.Error(w, e.Error(), 500)
return
}
// use as raw json
request := json.RawMessage(br)
// create request/response
var response json.RawMessage
req := (*cmd.DefaultOptions().Client).NewJsonRequest(service, method, &request)
// create context
ctx := helper.RequestToContext(r)
// make the call
if err := (*cmd.DefaultOptions().Client).Call(ctx, req, &response); err != nil {
ce := errors.Parse(err.Error())
switch ce.Code {
case 0:
// assuming it's totally screwed
ce.Code = 500
ce.Id = "go.micro.api"
ce.Status = http.StatusText(500)
ce.Detail = "error during request: " + ce.Detail
w.WriteHeader(500)
default:
w.WriteHeader(int(ce.Code))
}
w.Write([]byte(ce.Error()))
return
}
b, _ := response.MarshalJSON()
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
w.Write(b)
case "application/proto", "application/protobuf":
// get request
br, err := ioutil.ReadAll(r.Body)
if err != nil {
e := errors.InternalServerError("go.micro.api", err.Error())
http.Error(w, e.Error(), 500)
return
}
// use as raw proto
request := proto.NewMessage(br)
// create request/response
response := &proto.Message{}
req := (*cmd.DefaultOptions().Client).NewProtoRequest(service, method, request)
// create context
ctx := helper.RequestToContext(r)
// make the call
if err := (*cmd.DefaultOptions().Client).Call(ctx, req, response); err != nil {
ce := errors.Parse(err.Error())
switch ce.Code {
case 0:
// assuming it's totally screwed
ce.Code = 500
ce.Id = "go.micro.api"
ce.Status = http.StatusText(500)
ce.Detail = "error during request: " + ce.Detail
w.WriteHeader(500)
default:
w.WriteHeader(int(ce.Code))
}
// response content type
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(ce.Error()))
return
}
b, _ := response.Marshal()
w.Header().Set("Content-Type", r.Header.Get("Content-Type"))
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
w.Write(b)
default:
http.Error(w, "unknown content-type", 500)
return
}
}
func processOverview(config Config, attachment *Attachment) {
ec2client := ec2.New(session.New(), &aws.Config{Region: aws.String(config.General.DefaultRegion)})
regions, err := ec2client.DescribeRegions(&ec2.DescribeRegionsInput{})
if err != nil {
panic(err)
}
fmt.Println("Regions:")
for _, region := range regions.Regions {
fmt.Println("-", *region.RegionName)
}
ec2client = ec2.New(session.New(), &aws.Config{Region: aws.String(config.General.DefaultRegion)})
instances, err := ec2client.DescribeInstances(nil)
if err != nil {
panic(err)
}
fmt.Println("Instances:")
instanceCount := 0
instanceMap := make(map[string]ec2.Instance)
for _, reservation := range instances.Reservations {
for _, instance := range reservation.Instances {
fmt.Println("-", *instance.InstanceId)
instanceMap[*instance.InstanceId] = *instance
if *instance.State.Name == "running" {
instanceCount++
}
}
}
attachment.Fields = append(attachment.Fields, Field{Title: "Running instances", Value: fmt.Sprintf("%d", instanceCount), Short: true})
volumes, err := ec2client.DescribeVolumes(nil)
if err != nil {
panic(err)
}
attachment.Fields = append(attachment.Fields, Field{Title: "Volumes", Value: fmt.Sprintf("%d", len(volumes.Volumes)), Short: true})
securityGroups, err := ec2client.DescribeSecurityGroups(nil)
if err != nil {
panic(err)
}
securityGroupMap := make(map[string]ec2.SecurityGroup)
for _, securityGroup := range securityGroups.SecurityGroups {
securityGroupMap[*securityGroup.GroupId] = *securityGroup
}
vpcs, err := ec2client.DescribeVpcs(nil)
if err != nil {
panic(err)
}
subnets, err := ec2client.DescribeSubnets(nil)
if err != nil {
panic(err)
}
routeTables, err := ec2client.DescribeRouteTables(nil)
if err != nil {
panic(err)
}
vpcPeeringConnections, err := ec2client.DescribeVpcPeeringConnections(nil)
if err != nil {
panic(err)
}
s3client := s3.New(session.New(), &aws.Config{Region: aws.String(config.General.DefaultRegion)})
buckets, err := s3client.ListBuckets(nil)
if err != nil {
panic(err)
}
attachment.Fields = append(attachment.Fields, Field{Title: "S3 buckets", Value: fmt.Sprintf("%d", len(buckets.Buckets)), Short: true})
rdsclient := rds.New(session.New(), &aws.Config{Region: aws.String(config.General.DefaultRegion)})
dbInstances, err := rdsclient.DescribeDBInstances(nil)
if err != nil {
panic(err)
}
attachment.Fields = append(attachment.Fields, Field{Title: "DB instances", Value: fmt.Sprintf("%d", len(dbInstances.DBInstances)), Short: true})
overview := Overview{Instances: instances, SecurityGroups: securityGroups, Vpcs: vpcs, Subnets: subnets, RouteTables: routeTables, VpcPeeringConnections: vpcPeeringConnections, Buckets: buckets, DBInstances: dbInstances}
jsonData, err := json.MarshalIndent(overview, "", " ")
if err != nil {
panic(err)
}
const outputDir = "/tmp"
err = os.MkdirAll(outputDir, os.ModeDir)
if err != nil {
panic(err)
}
err = ioutil.WriteFile(outputDir+"/aws.json", jsonData, 0777)
if err != nil {
panic(err)
}
var m json.RawMessage
err = m.UnmarshalJSON(jsonData)
if err != nil {
panic(err)
}
}