func (s *Server) getMember(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
tribeLogger = tribeLogger.WithField("_block", "getMember")
name := p.ByName("name")
member := s.tr.GetMember(name)
if member == nil {
fields := map[string]interface{}{
"name": name,
}
tribeLogger.WithFields(fields).Error(ErrMemberNotFound)
respond(404, rbody.FromSnapError(serror.New(ErrMemberNotFound, fields)), w)
return
}
resp := &rbody.TribeMemberShow{
Name: member.Name,
Tags: member.Tags,
}
if member.PluginAgreement != nil {
resp.PluginAgreement = member.PluginAgreement.Name
}
for k, t := range member.TaskAgreements {
if len(t.Tasks) > 0 {
resp.TaskAgreements = append(resp.TaskAgreements, k)
}
}
respond(200, resp, w)
}
func (s *Server) unloadPlugin(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
plName := p.ByName("name")
plType := p.ByName("type")
plVersion, iErr := strconv.ParseInt(p.ByName("version"), 10, 0)
f := map[string]interface{}{
"plugin-name": plName,
"plugin-version": plVersion,
"plugin-type": plType,
}
if iErr != nil {
se := serror.New(errors.New("invalid version"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
if plName == "" {
se := serror.New(errors.New("missing plugin name"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
if plType == "" {
se := serror.New(errors.New("missing plugin type"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
up, se := s.mm.Unload(&plugin{
name: plName,
version: int(plVersion),
pluginType: plType,
})
if se != nil {
se.SetFields(f)
respond(500, rbody.FromSnapError(se), w)
return
}
pr := &rbody.PluginUnloaded{
Name: up.Name(),
Version: up.Version(),
Type: up.TypeName(),
}
respond(200, pr, w)
}
func (s *Server) joinAgreement(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
tribeLogger = tribeLogger.WithField("_block", "joinAgreement")
name := p.ByName("name")
if _, ok := s.tr.GetAgreements()[name]; !ok {
fields := map[string]interface{}{
"agreement_name": name,
}
tribeLogger.WithFields(fields).Error(ErrAgreementDoesNotExist)
respond(400, rbody.FromSnapError(serror.New(ErrAgreementDoesNotExist, fields)), w)
return
}
b, err := ioutil.ReadAll(r.Body)
if err != nil {
tribeLogger.Error(err)
respond(500, rbody.FromError(err), w)
return
}
m := struct {
MemberName string `json:"member_name"`
}{}
err = json.Unmarshal(b, &m)
if err != nil {
fields := map[string]interface{}{
"error": err,
"hint": `The body of the request should be of the form '{"member_name": "some_value"}'`,
}
se := serror.New(ErrInvalidJSON, fields)
tribeLogger.WithFields(fields).Error(ErrInvalidJSON)
respond(400, rbody.FromSnapError(se), w)
return
}
serr := s.tr.JoinAgreement(name, m.MemberName)
if serr != nil {
tribeLogger.Error(serr)
respond(400, rbody.FromSnapError(serr), w)
return
}
agreement, _ := s.tr.GetAgreement(name)
respond(200, &rbody.TribeJoinAgreement{Agreement: agreement}, w)
}
func (s *Server) addAgreement(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
tribeLogger = tribeLogger.WithField("_block", "addAgreement")
b, err := ioutil.ReadAll(r.Body)
if err != nil {
tribeLogger.Error(err)
respond(500, rbody.FromError(err), w)
return
}
a := struct{ Name string }{}
err = json.Unmarshal(b, &a)
if err != nil {
fields := map[string]interface{}{
"error": err,
"hint": `The body of the request should be of the form '{"name": "agreement_name"}'`,
}
se := serror.New(ErrInvalidJSON, fields)
tribeLogger.WithFields(fields).Error(ErrInvalidJSON)
respond(400, rbody.FromSnapError(se), w)
return
}
if a.Name == "" {
fields := map[string]interface{}{
"hint": `The body of the request should be of the form '{"name": "agreement_name"}'`,
}
se := serror.New(ErrInvalidJSON, fields)
tribeLogger.WithFields(fields).Error(ErrInvalidJSON)
respond(400, rbody.FromSnapError(se), w)
return
}
err = s.tr.AddAgreement(a.Name)
if err != nil {
tribeLogger.WithField("agreement-name", a.Name).Error(err)
respond(400, rbody.FromError(err), w)
return
}
res := &rbody.TribeAddAgreement{}
res.Agreements = s.tr.GetAgreements()
respond(200, res, w)
}
func (s *Server) getAgreement(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
tribeLogger = tribeLogger.WithField("_block", "getAgreement")
name := p.ByName("name")
if _, ok := s.tr.GetAgreements()[name]; !ok {
fields := map[string]interface{}{
"agreement_name": name,
}
tribeLogger.WithFields(fields).Error(ErrAgreementDoesNotExist)
respond(400, rbody.FromSnapError(serror.New(ErrAgreementDoesNotExist, fields)), w)
return
}
a := &rbody.TribeGetAgreement{}
var serr serror.SnapError
a.Agreement, serr = s.tr.GetAgreement(name)
if serr != nil {
tribeLogger.Error(serr)
respond(400, rbody.FromSnapError(serr), w)
return
}
respond(200, a, w)
}
func (s *Server) getPlugin(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
plName := p.ByName("name")
plType := p.ByName("type")
plVersion, iErr := strconv.ParseInt(p.ByName("version"), 10, 0)
f := map[string]interface{}{
"plugin-name": plName,
"plugin-version": plVersion,
"plugin-type": plType,
}
if iErr != nil {
se := serror.New(errors.New("invalid version"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
if plName == "" {
se := serror.New(errors.New("missing plugin name"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
if plType == "" {
se := serror.New(errors.New("missing plugin type"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
pluginCatalog := s.mm.PluginCatalog()
var plugin core.CatalogedPlugin
for _, item := range pluginCatalog {
if item.Name() == plName &&
item.Version() == int(plVersion) &&
item.TypeName() == plType {
plugin = item
break
}
}
if plugin == nil {
se := serror.New(ErrPluginNotFound, f)
respond(404, rbody.FromSnapError(se), w)
return
}
rd := r.FormValue("download")
d, _ := strconv.ParseBool(rd)
if d {
b, err := ioutil.ReadFile(plugin.PluginPath())
if err != nil {
f["plugin-path"] = plugin.PluginPath()
se := serror.New(err, f)
respond(500, rbody.FromSnapError(se), w)
return
}
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
_, err = gz.Write(b)
if err != nil {
f["plugin-path"] = plugin.PluginPath()
se := serror.New(err, f)
respond(500, rbody.FromSnapError(se), w)
return
}
return
} else {
pluginRet := &rbody.PluginReturned{
Name: plugin.Name(),
Version: plugin.Version(),
Type: plugin.TypeName(),
Signed: plugin.IsSigned(),
Status: plugin.Status(),
LoadedTimestamp: plugin.LoadedTimestamp().Unix(),
Href: catalogedPluginURI(r.Host, plugin),
}
respond(200, pluginRet, w)
}
}
func (s *Server) getPlugin(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
plName := p.ByName("name")
plType := p.ByName("type")
plVersion, iErr := strconv.ParseInt(p.ByName("version"), 10, 0)
f := map[string]interface{}{
"plugin-name": plName,
"plugin-version": plVersion,
"plugin-type": plType,
}
if iErr != nil {
se := serror.New(errors.New("invalid version"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
if plName == "" {
se := serror.New(errors.New("missing plugin name"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
if plType == "" {
se := serror.New(errors.New("missing plugin type"))
se.SetFields(f)
respond(400, rbody.FromSnapError(se), w)
return
}
pluginCatalog := s.mm.PluginCatalog()
var plugin core.CatalogedPlugin
for _, item := range pluginCatalog {
if item.Name() == plName &&
item.Version() == int(plVersion) &&
item.TypeName() == plType {
plugin = item
break
}
}
if plugin == nil {
se := serror.New(ErrPluginNotFound, f)
respond(404, rbody.FromSnapError(se), w)
return
}
rd := r.FormValue("download")
d, _ := strconv.ParseBool(rd)
var configPolicy []rbody.PolicyTable
if plugin.TypeName() == "processor" || plugin.TypeName() == "publisher" {
rules := plugin.Policy().Get([]string{""}).RulesAsTable()
configPolicy = make([]rbody.PolicyTable, 0, len(rules))
for _, r := range rules {
configPolicy = append(configPolicy, rbody.PolicyTable{
Name: r.Name,
Type: r.Type,
Default: r.Default,
Required: r.Required,
Minimum: r.Minimum,
Maximum: r.Maximum,
})
}
} else {
configPolicy = nil
}
if d {
b, err := ioutil.ReadFile(plugin.PluginPath())
if err != nil {
f["plugin-path"] = plugin.PluginPath()
se := serror.New(err, f)
respond(500, rbody.FromSnapError(se), w)
return
}
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
_, err = gz.Write(b)
if err != nil {
f["plugin-path"] = plugin.PluginPath()
se := serror.New(err, f)
respond(500, rbody.FromSnapError(se), w)
return
}
return
} else {
pluginRet := &rbody.PluginReturned{
Name: plugin.Name(),
Version: plugin.Version(),
Type: plugin.TypeName(),
Signed: plugin.IsSigned(),
Status: plugin.Status(),
LoadedTimestamp: plugin.LoadedTimestamp().Unix(),
Href: pluginURI(r.Host, plugin),
ConfigPolicy: configPolicy,
}
respond(200, pluginRet, w)
}
}
