Пример #1
0
func main() {
	t0 := time.Now()
	conf := config.Config{}
	conf.MusicDir = flag.String("music-dir", "/music", "Music dir")
	conf.Port = flag.Int("port", 8080, "Pickup port")
	conf.MpdAddress = flag.String("mpd-address", "localhost:6600", "MPD address")
	conf.MpdPassword = flag.String("mpd-password", "", "MPD Password")

	flag.Parse(true)

	log.Printf("Mpd address: '%s'  password: '******'\n", *conf.MpdAddress,
		*conf.MpdPassword)

	plyr, err := player.NewMpdPlayer(&conf)
	if err != nil {
		log.Fatalln("Failed to initialize mpd player", err)
	}
	music, err := plyr.GetCollection()
	if err != nil {
		log.Fatalln("Failed to retrieve collection", err)
	}
	log.Printf("Player with %d categories initialized in %v\n", len(music.Categories), time.Since(t0))

	serve(&conf, &plyr)
}
Пример #2
0
func main() {
	var action = flag.String("action", "serve", "Action to perform (serve|refresh)")
	conf := config.Config{}
	conf.MusicDir = flag.String("music-dir", "/music", "Music dir")
	conf.Port = flag.Int("port", 8080, "Pickup port")
	conf.MpdAddress = flag.String("mpd-address", "localhost:6600", "MPD address")
	conf.MpdPassword = flag.String("mpd-password", "", "MPD Password")

	var query = flag.String("query", "", "Search query")
	flag.Parse(true)

	fmt.Println("Action is:", *action)
	fmt.Printf("Mpd address: '%s'  password: '******'\n", *conf.MpdAddress,
		*conf.MpdPassword)

	//collection := loadOrRefresh(*conf.MusicDir)
	music, err := model.RefreshMpd(&conf)
	if err != nil {
		log.Fatalf("Couldn't get files from mpd: \n%s\n", err)
	}

	switch *action {
	case "stats":
		stats(music.Categories[0])
	case "search":
		search(music, *query)
	case "serve":
		serve(&conf, music)
	case "test-playback":
		testPlayback(&conf, music)
	case "refresh":
		os.Exit(0)
	default:
		fmt.Println("Unknown action", *action)
	}
}
Пример #3
0
	flag "launchpad.net/gnuflag"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strconv"
	"strings"
	"syscall"
	"time"
)

var VERSION string
var MINVERSION string

var helpFlag = flag.Bool("help", false, "Show this screen")
var tracksFlag = flag.String("tracks", "", "Comma separated list of track_ids eg. 123,231,122")
var fileFlag = flag.String("file", "", "A file of line separated track_ids")
var playedTracksCount = map[string]int{}
var tracks []TrackInfo

var HTTP_ERR_RETRY = time.Duration(10)
var HTTP_GET_ERROR = "HTTP GET for %s failed.\nWaiting 10s and trying again.."
var HTTP_ETAG_GET_ERROR = "ETAG cached HTTP GET for %s failed.\nWaiting 10s and trying again.."

func output_welcome() {
	fmt.Printf("\033]0;unearthd-bumpr v%s\007", VERSION)
	fmt.Println()
	fmt.Printf("Unearthd Track Bumpr - v%s\n", VERSION)
	fmt.Println("Created by NUR (Never Underestimate Reason)")
	fmt.Println()
}
Пример #4
0
	"unicode"
)

var VERSION string
var MINVERSION string

var STD_OUT = bufio.NewWriter(colorable.NewColorableStdout())
var STD_ERR = bufio.NewWriter(colorable.NewColorableStderr())
var STD_IN = bufio.NewReader(os.Stdin)

var DATABASE_FILENAME = "cover_urls.boltdb"
var DATABASE_BUCKET = []byte("CoverImages")
var DEFAULT_OUTPUT_FILENAME = "output.jpg"

var aboutFlag = flag.Bool("about", false, "About the application")
var trackListFlag = flag.String("tracklist", "", "A file containing a tracklist")
var outputFileFlag = flag.String("output", "", "The file to output the generate cover to")
var overlayFlag = flag.String("overlay", "", "A file to overlay on top of the generated image")

func main() {

	flag.Parse(true)
	showWelcomeMessage()
	if *aboutFlag == true {
		showAboutMessage()
		os.Exit(0)
	}

	var tracklist []Track
	tracklistFileName := ""
Пример #5
0
func main() {
	foreground := flag.Bool("f", false, "Run application foreground, don't daemonize")
	config_path := flag.String("config", "config.json", "Configuration file path")
	pid_path := flag.String("pid", "/var/run/ng_backend.pid", "PID file path")
	flag.Parse(false)
	init_config(*config_path)
	d_config := get_daemon_config()
	state_config := get_state_config()
	metric_config := get_metric_config()
	graph_config := get_graph_config()

	if !*foreground {
		cntxt := &daemon.Context{
			PidFileName: *pid_path,
			PidFilePerm: 0644,
			LogFileName: d_config.GetString("log_file"),
			LogFilePerm: 0640,
			WorkDir:     "./",
			Umask:       027,
			Args:        []string{},
		}

		d, err := cntxt.Reborn()
		if err != nil {
			log.Fatalln(err)
		}
		if d != nil {
			return
		}
		defer cntxt.Release()
	}

	log.Println("Starting NetAssist NetGraphz2...")

	log.Printf("Create memory metric storage with capacity of %d records per metric\n", metric_config.GetInt("mem_storage.capacity"))

	metric_store := metric.NewMemoryStorage(metric_config.GetInt("mem_storage.capacity"))
	status_srv := state.NewStatusService(state.NewMemoryStateCache(), time.Duration(state_config.GetInt("cache.ttl"))*time.Millisecond)
	graph_store := graph.NewNeoGraphStorage(graph_config.GetString("url"))

	icinga_config := state.IcingaLiveStatusConfig{}
	icinga_config.HostName = state_config.GetString("icinga.host")
	icinga_config.Port = uint16(state_config.GetInt("icinga.port"))
	icinga_config.UseUnixSocket = state_config.GetBool("icinga.use_unix_socket")
	icinga_config.UnixSocket = state_config.GetString("icinga.unix_socket")
	icinga_config.TimeoutEnable = state_config.GetBool("icinga.timeout_enabled")
	icinga_config.Timeout = time.Duration(state_config.GetInt("icinga.timeout")) * time.Millisecond

	icinga_source := state.NewIcingaLiveStateSource(icinga_config)
	status_srv.AddSource(icinga_source)

	lis, err := net.Listen("tcp", net.JoinHostPort(d_config.GetString("rpc_host"), fmt.Sprintf("%d", d_config.GetInt("rpc_port"))))
	if err != nil {
		log.Printf("failed to listen: %v", err)
	}
	var opts []grpc.ServerOption
	grpcServer := grpc.NewServer(opts...)
	rpc.RegisterBackendServer(grpcServer, rpc_server.NewRPCServer(graph_store, status_srv, metric_store))

	go func() {
		log.Printf("gRPC server starting on %s:%d\n", d_config.GetString("rpc_host"), d_config.GetInt("rpc_port"))
		err := grpcServer.Serve(lis)
		if err != nil {
			log.Fatalf("Error during listening: %v\n", err)
		}
	}()

	log.Printf("Starting collectd listener on %s:%d\n", metric_config.GetString("collectd.host"), metric_config.GetInt("collectd.port"))

	source := metric.NewCollectdMetricSource(metric_config.GetString("collectd.host"), uint16(metric_config.GetInt("collectd.port")), metric_config.GetBool("collectd.filter_enable"), metric_config.GetStringSlice("collectd.filter_types"))
	source.AddStorage(metric_store)
	log.Println("Collecting collectd metrics")
	source.Collect()
}
Пример #6
0
// license that can be found in the LICENSE file.

package tsuru

import (
	"encoding/json"
	"fmt"
	"github.com/globocom/tsuru/cmd"
	"io"
	"io/ioutil"
	"launchpad.net/gnuflag"
	"net/http"
	"strings"
)

var AppName = gnuflag.String("app", "", "App name for running app related commands.")
var LogLines = gnuflag.Int("lines", 10, "The number of log lines to display")
var LogSource = gnuflag.String("source", "", "The log from the given source")

type AppInfo struct {
	GuessingCommand
}

func (c *AppInfo) Info() *cmd.Info {
	return &cmd.Info{
		Name:  "app-info",
		Usage: "app-info [--app appname]",
		Desc: `show information about your app.

If you don't provide the app name, tsuru will try to guess it.`,
		MinArgs: 0,
Пример #7
0
	"sort"
	"time"
	"unicode/utf8"

	"github.com/juju/errors"
	"github.com/juju/juju/cmd/envcmd"
	"github.com/juju/juju/environs"
	"github.com/juju/juju/environs/configstore"
	"github.com/juju/juju/juju"
	"github.com/juju/juju/juju/osenv"
	"github.com/juju/juju/state/api"
	"github.com/juju/names"
)

var (
	envName = flag.String("e", "", "environment name")
	verbose = flag.Bool("v", false, "verbose")
	timeout = flag.Duration("timeout", 5*time.Minute, "maximum timeout")
)

func main() {
	flag.Parse(true)
	if err := main0(); err != nil {
		fmt.Fprintf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
}

var startTime = time.Now()

func main0() error {
Пример #8
0
var OAUTH_REDIRECT_URI = "http://www.rhythmandpoetry.net/mixcloud_code.php"
var API_URL = "https://api.mixcloud.com/upload/?access_token="
var ACCESS_TOKEN_URL = "https://www.mixcloud.com/oauth/access_token?client_id=" + OAUTH_CLIENT_ID + "&redirect_uri=" + OAUTH_REDIRECT_URI + "&client_secret=" + OAUTH_CLIENT_SECRET + "&code=%s"
var API_ME_URL = "https://api.mixcloud.com/me?access_token="
var CONFIG_FILE = "config.json"
var CONFIG_FILE_PATH = ""

var TRACKLIST_OUTPUT_FORMAT = "%d. %s-%s\n"

var CURRENT_USER mixcloud.User = mixcloud.User{}
var configuration = Configuration{}

var aboutFlag = flag.Bool("about", false, "About the application")
var configFlag = flag.Bool("config", false, "Configure the application")
var fileFlag = flag.String("file", "", "The mp3 file to upload to mixcloud")
var coverFlag = flag.String("cover", "", "The image file to upload to mixcloud as the cover")
var trackListFlag = flag.String("tracklist", "", "A file containing a VirtualDJ Tracklist for the cloudcast")

var STD_OUT = bufio.NewWriter(colorable.NewColorableStdout())
var STD_ERR = bufio.NewWriter(colorable.NewColorableStderr())
var STD_IN = bufio.NewReader(os.Stdin)

type Configuration struct {
	ACCESS_TOKEN string
	DEFAULT_TAGS string
}

func showWelcomeMessage() {
	OutputMessage(term.Green + "Mixcloud CLI Uploader v" + VERSION + term.Reset + "\n\n")
}