func (v *vm) Machine(id string) (vms.Machine, error) { rows, err := db.Query( `SELECT id, name, ip, plazaport, username, password FROM machines WHERE id = $1::varchar`, id) if err != nil { fmt.Println(err.Error()) return nil, err } machine := &machine{} for rows.Next() { rows.Scan( &machine.id, &machine.name, &machine.server, &machine.plazaport, &machine.user, &machine.password, ) } err = rows.Err() if err != nil { log.Error(err.Error()) return nil, err } return machine, nil }
func (m *machine) Status() (vms.MachineStatus, error) { var service string if m.role == "ad" { service = "ADWS" } else if m.role == "exec" { service = "RDMS" } cmd := exec.Command( "sshpass", "-p", m.password, "ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=1", "-o", "UserKnownHostsFile=/dev/null", "-p", m.sshport, fmt.Sprintf( "%s@%s", m.user, m.server, ), "powershell.exe \"Write-Host (Get-Service -Name "+service+").status\"", ) response, err := cmd.CombinedOutput() if err != nil { log.Error("Failed to check windows' state", err, string(response)) return vms.StatusUnknown, err } if strings.Contains(string(response), "Running") { return vms.StatusUp, nil } return vms.StatusDown, nil }
func ExecuteCommandAsAdmin(cmd, username, pwd, domain string) { out, err := exec.Command(cmd).Output() if err != nil { log.Error(err) } log.Info(out) }
func ExecuteCommandAsAdmin(cmd, username, pwd, domain string) { var si startupinfo var handle HANDLE var pi processinfo si.cb = uint32(unsafe.Sizeof(si)) a := syscall.MustLoadDLL("advapi32.dll") LogonUserW := a.MustFindProc("LogonUserW") r1, r2, lastError := LogonUserW.Call( uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(username))), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(domain))), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(pwd))), LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, uintptr(unsafe.Pointer(&handle)), ) log.Error(r1) log.Error(r2) log.Error(lastError) CreateProcessAsUser := a.MustFindProc("CreateProcessAsUserW") r1, r2, lastError = CreateProcessAsUser.Call( uintptr(unsafe.Pointer(handle)), uintptr(unsafe.Pointer(nil)), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(cmd))), uintptr(unsafe.Pointer(nil)), uintptr(unsafe.Pointer(nil)), uintptr(0), uintptr(unsafe.Pointer(nil)), uintptr(unsafe.Pointer(nil)), uintptr(unsafe.Pointer(nil)), uintptr(unsafe.Pointer(&si)), uintptr(unsafe.Pointer(&pi)), ) log.Error(r1) log.Error(r2) log.Error(lastError) b := syscall.MustLoadDLL("Kernel32.dll") CloseHandle := b.MustFindProc("CloseHandle") r1, r2, lastError = CloseHandle.Call( uintptr(unsafe.Pointer(handle)), ) log.Error(r1) log.Error(r2) log.Error(lastError) }
func (m *machine) Status() (vms.MachineStatus, error) { resp, err := http.Get("http://" + m.server + ":" + m.plazaport + "/checkrds") if err != nil || resp.StatusCode != http.StatusOK { log.Error(err) return vms.StatusUnknown, nil } b, err := ioutil.ReadAll(resp.Body) if err != nil { log.Error(err) return vms.StatusUnknown, nil } if strings.Contains(string(b), "Running") { return vms.StatusUp, nil } return vms.StatusDown, nil }
func realMain() int { // reads and parses application config params config, err := config.ReadFromFile("./config.json") if err != nil { fmt.Println("Config file reading error. Details: ", err) return 1 } // creates Logger (can be replaced with other popular logger) log := log.New("GOB ") log.Debug("Application launched") // creates Backend object back, err := backend.New(&config.Backend, log) if err != nil { log.Error("Backend initialisation error. Details: ", err) return 2 } // creates Frontend objects front, err := frontend.New(&config.Frontend, log, back) if err != nil { log.Error("Frontend initialisation error. Details: ", err) return 3 } // starts background processes if err := back.Start(); err != nil { log.Error("Backend processes launching error. Details: ", err) return 4 } // starts HTTP listener and handlers if err := front.Start(); err != nil { log.Error("Frontend listeners/processes error. Details: ", err) return 5 } log.Info("Application succesfully terminated") return 0 }
func TestFiles(t *testing.T) { path, _ := filepath.Abs(".") s, err := New(path, OutputJson) if err != nil { t.Fail() } if s.String() != testData { log.Error("Unexpected data") t.Fail() } }
func (m *machine) Status() (vms.MachineStatus, error) { resp, err := http.Get("http://" + m.server + ":" + m.plazaport + "/") if err != nil { log.Error(err) return vms.StatusDown, nil } if resp.StatusCode != http.StatusOK { return vms.StatusUnknown, nil } return vms.StatusUp, nil }
func (d *MachineDriver) GetReferencedStructs() []jsonapi.MarshalIdentifier { types, err := vms.Types() if err != nil { log.Error(err) return nil } rt := make([]jsonapi.MarshalIdentifier, 0) for _, t := range types { rt = append(rt, t) } return rt }
// ValidateUsername checks to see if the username is in use func (u Controller) ValidateUsername(e echo.Context) error { name := e.Param("name") count, err := models.Users(u.DB, qm.Where("username=?", name)).Count() if err != nil { log.Error("failed to get user from db", "err", err) return e.NoContent(http.StatusInternalServerError) } if count > 0 { return e.NoContent(http.StatusNotAcceptable) } return e.NoContent(http.StatusOK) }
func (h *handler) SearchbackHandler(c *echo.Context) error { searchq := strings.ToLower(c.Query("search")) packages, err := h.back.Model.Package.GetItems(searchq) if err != nil { log.Error(err) return c.Redirect(http.StatusTemporaryRedirect, "/") } if len(searchq) > 50 && len(searchq) < 4 { return c.Redirect(http.StatusBadRequest, "/") } data := struct { Packages []model.PackageRow }{ packages, } return c.Render(http.StatusOK, "search.html", data) }
func (d *MachineDriver) GetReferencedIDs() []jsonapi.ReferenceID { types, err := vms.Types() if err != nil { log.Error(err) return nil } rt := make([]jsonapi.ReferenceID, 0) for _, t := range types { rt = append(rt, jsonapi.ReferenceID{ ID: t.GetID(), Type: "machine-types", Name: "types", }) } return rt }
// New creates an instance of Echo. func New() (e *Echo) { e = &Echo{maxParam: new(int)} e.pool.New = func() interface{} { return NewContext(nil, new(Response), e) } e.router = NewRouter(e) //---------- // Defaults //---------- e.HTTP2(true) e.defaultHTTPErrorHandler = func(err error, c *Context) { code := http.StatusInternalServerError msg := http.StatusText(code) if he, ok := err.(*HTTPError); ok { code = he.code msg = he.message } if e.debug { msg = err.Error() } if !c.response.committed { http.Error(c.response, msg, code) } log.Error(err) } e.SetHTTPErrorHandler(e.defaultHTTPErrorHandler) e.SetBinder(&binder{}) // Logger log.SetPrefix("echo") log.SetLevel(log.INFO) return }