func MoviesMostVoted(ctx *gin.Context) {
page := -1
if config.Get().EnablePaging == true {
currentpage, err := strconv.Atoi(ctx.DefaultQuery("page", "0"))
if err == nil {
page = currentpage
}
}
renderMovies(tmdb.MostVotedMoviesComplete("", config.Get().Language, page), ctx, page)
}
func TopRatedShows(ctx *gin.Context) {
page := -1
if config.Get().EnablePaging == true {
currentpage, err := strconv.Atoi(ctx.DefaultQuery("page", "0"))
if err == nil {
page = currentpage
}
}
renderShows(tmdb.TopRatedShowsComplete("", config.Get().Language, page), ctx, page)
}
func MakePulsarRepositoryAddon() error {
addonId := "repository.pulsar"
addonName := "Pulsar Repository"
pulsarHost := fmt.Sprintf("http://localhost:%d", config.ListenPort)
addon := &xbmc.Addon{
Id: addonId,
Name: addonName,
Version: util.Version,
ProviderName: config.Get().Info.Author,
Extensions: []*xbmc.AddonExtension{
&xbmc.AddonExtension{
Point: "xbmc.addon.repository",
Name: addonName,
Info: &xbmc.AddonRepositoryInfo{
Text: pulsarHost + "/repository/steeve/plugin.video.pulsar/addons.xml",
Compressed: false,
},
Checksum: pulsarHost + "/repository/steeve/plugin.video.pulsar/addons.xml.md5",
Datadir: &xbmc.AddonRepositoryDataDir{
Text: pulsarHost + "/repository/steeve/",
Zip: true,
},
},
&xbmc.AddonExtension{
Point: "xbmc.addon.metadata",
Summaries: []*xbmc.AddonText{
&xbmc.AddonText{"Virtual repository for Pulsar Updates", "en"},
},
Platform: "all",
},
},
}
addonPath := filepath.Clean(filepath.Join(config.Get().Info.Path, "..", addonId))
if err := os.MkdirAll(addonPath, 0777); err != nil {
return err
}
if err := copyFile(filepath.Join(config.Get().Info.Path, "icon.png"), filepath.Join(addonPath, "icon.png")); err != nil {
return err
}
addonXmlFile, err := os.Create(filepath.Join(addonPath, "addon.xml"))
if err != nil {
return err
}
defer addonXmlFile.Close()
return xml.NewEncoder(addonXmlFile).Encode(addon)
}
func PopularMovies(ctx *gin.Context) {
genre := ctx.Params.ByName("genre")
if genre == "0" {
genre = ""
}
page := -1
if config.Get().EnablePaging == true {
currentpage, err := strconv.Atoi(ctx.DefaultQuery("page", "0"))
if err == nil {
page = currentpage
}
}
renderMovies(tmdb.PopularMoviesComplete(genre, config.Get().Language, page), ctx, page)
}
func GetShow(showId int, language string) *Show {
var show *Show
cacheStore := cache.NewFileStore(path.Join(config.Get().ProfilePath, "cache"))
key := fmt.Sprintf("com.tmdb.show.%d.%s", showId, language)
if err := cacheStore.Get(key, &show); err != nil {
rateLimiter.Call(func() {
p := napping.Params{"api_key": apiKey, "append_to_response": "credits,images,alternative_titles,translations,external_ids", "language": language}.AsUrlValues()
napping.Get(
tmdbEndpoint+"tv/"+strconv.Itoa(showId),
&p,
&show,
nil,
)
})
if show != nil {
cacheStore.Set(key, show, cacheTime)
}
}
if show == nil {
return nil
}
switch t := show.RawPopularity.(type) {
case string:
if popularity, err := strconv.ParseFloat(t, 64); err == nil {
show.Popularity = popularity
}
case float64:
show.Popularity = t
}
return show
}
func getMovieById(movieId string, language string) *Movie {
var movie *Movie
cacheStore := cache.NewFileStore(path.Join(config.Get().ProfilePath, "cache"))
key := fmt.Sprintf("com.tmdb.movie.%s.%s", movieId, language)
if err := cacheStore.Get(key, &movie); err != nil {
rateLimiter.Call(func() {
p := napping.Params{"api_key": apiKey, "append_to_response": "credits,images,alternative_titles,translations,external_ids,trailers", "language": language}.AsUrlValues()
napping.Get(
tmdbEndpoint+"movie/"+movieId,
&p,
&movie,
nil,
)
if movie != nil {
cacheStore.Set(key, movie, cacheTime)
}
})
}
if movie == nil {
return nil
}
switch t := movie.RawPopularity.(type) {
case string:
popularity, _ := strconv.ParseFloat(t, 64)
movie.Popularity = popularity
case float64:
movie.Popularity = t
}
return movie
}
func (as *AddonSearcher) call(method string, searchObject interface{}) []*bittorrent.Torrent {
torrents := make([]*bittorrent.Torrent, 0)
cid, c := GetCallback()
cbUrl := fmt.Sprintf("%s/callbacks/%s", util.GetHTTPHost(), cid)
payload := &SearchPayload{
Method: method,
CallbackURL: cbUrl,
SearchObject: searchObject,
}
xbmc.ExecuteAddon(as.addonId, payload.String())
timeout := providerTimeout()
conf := config.Get()
if conf.CustomProviderTimeoutEnabled == true {
timeout = time.Duration(conf.CustomProviderTimeout) * time.Second
}
select {
case <-time.After(timeout):
as.log.Info("Provider %s was too slow. Ignored.", as.addonId)
RemoveCallback(cid)
case result := <-c:
json.Unmarshal(result, &torrents)
}
return torrents
}
func ShowEpisodes(ctx *gin.Context) {
show, err := tvdb.NewShowCached(ctx.Params.ByName("showId"), config.Get().Language)
if err != nil {
ctx.Error(err)
return
}
seasonNumber, _ := strconv.Atoi(ctx.Params.ByName("season"))
season := show.Seasons[seasonNumber]
items := season.Episodes.ToListItems(show)
for _, item := range items {
item.Path = UrlForXBMC("/show/%d/season/%d/episode/%d/play",
show.Id,
season.Season,
item.Info.Episode,
)
item.ContextMenu = [][]string{
[]string{"LOCALIZE[30202]", fmt.Sprintf("XBMC.PlayMedia(%s)", UrlForXBMC("/show/%d/season/%d/episode/%d/links",
show.Id,
season.Season,
item.Info.Episode,
))},
[]string{"LOCALIZE[30203]", "XBMC.Action(Info)"},
}
item.IsPlayable = true
}
ctx.JSON(200, xbmc.NewView("episodes", items))
}
func SearchMovies(ctx *gin.Context) {
query := ctx.Request.URL.Query().Get("q")
if query == "" {
query = xbmc.Keyboard("", "LOCALIZE[30206]")
if query == "" {
return
}
}
renderMovies(tmdb.SearchMovies(query, config.Get().Language), ctx, -1)
}
func Migrate() {
firstRun := filepath.Join(config.Get().Info.Path, ".firstrun")
if _, err := os.Stat(firstRun); err == nil {
return
}
file, _ := os.Create(firstRun)
defer file.Close()
log.Info("Preparing for first run")
// Move ga client id file out of the cache directory
gaFile := filepath.Join(config.Get().Info.Profile, "cache", "io.steeve.pulsar.ga")
if _, err := os.Stat(gaFile); err == nil {
os.Rename(gaFile, filepath.Join(config.Get().Info.Profile, "io.steeve.pulsar.ga"))
}
gaFile = filepath.Join(config.Get().Info.Profile, "io.steeve.pulsar.ga")
if file, err := os.Open(gaFile); err == nil {
if gzReader, err := gzip.NewReader(file); err != nil {
outFile, _ := os.Create(gaFile + ".gz")
gzWriter := gzip.NewWriter(outFile)
file.Seek(0, os.SEEK_SET)
io.Copy(gzWriter, file)
gzWriter.Flush()
gzWriter.Close()
outFile.Close()
file.Close()
os.Rename(gaFile+".gz", gaFile)
} else {
gzReader.Close()
}
}
// Remove the cache
log.Info("Clearing cache")
os.RemoveAll(filepath.Join(config.Get().Info.Profile, "cache"))
log.Info("Creating Pulsar Repository Addon")
if err := repository.MakePulsarRepositoryAddon(); err != nil {
log.Error("Unable to create repository addon: %s", err)
}
}
func getClientId() string {
clientId := ""
key := "io.steeve.pulsar.ga"
cacheStore := cache.NewFileStore(path.Join(config.Get().ProfilePath))
if err := cacheStore.Get(key, &clientId); err != nil {
clientUUID, _ := uuid.NewV4()
clientId := clientUUID.String()
cacheStore.Set(key, clientId, clientIdCacheTime)
}
return clientId
}
func MovieGenres(ctx *gin.Context) {
genres := tmdb.GetMovieGenres(config.Get().Language)
items := make(xbmc.ListItems, 0, len(genres))
for _, genre := range genres {
items = append(items, &xbmc.ListItem{
Label: genre.Name,
Path: UrlForXBMC("/movies/popular/%s", strconv.Itoa(genre.Id)),
})
}
ctx.JSON(200, xbmc.NewView("", items))
}
func movieLinks(imdbId string) []*bittorrent.Torrent {
log.Println("Searching links for IMDB:", imdbId)
movie := tmdb.GetMovieFromIMDB(imdbId, config.Get().Language)
log.Printf("Resolved %s to %s\n", imdbId, movie.Title)
searchers := providers.GetMovieSearchers()
if len(searchers) == 0 {
xbmc.Notify("Pulsar", "LOCALIZE[30204]", config.AddonIcon())
}
return providers.SearchMovie(searchers, movie)
}
func TVIndex(ctx *gin.Context) {
items := xbmc.ListItems{
{Label: "LOCALIZE[30209]", Path: UrlForXBMC("/shows/search"), Thumbnail: config.AddonResource("img", "search.png")},
{Label: "LOCALIZE[30210]", Path: UrlForXBMC("/shows/popular"), Thumbnail: config.AddonResource("img", "popular.png")},
}
for _, genre := range tmdb.GetTVGenres(config.Get().Language) {
slug, _ := genreSlugs[genre.Id]
items = append(items, &xbmc.ListItem{
Label: genre.Name,
Path: UrlForXBMC("/shows/popular/%s", strconv.Itoa(genre.Id)),
Thumbnail: config.AddonResource("img", fmt.Sprintf("genre_%s.png", slug)),
})
}
ctx.JSON(200, xbmc.NewView("", items))
}
func NewShowCached(tvdbId string, language string) (*Show, error) {
var show *Show
cacheStore := cache.NewFileStore(path.Join(config.Get().ProfilePath, "cache"))
key := fmt.Sprintf("com.tvdb.show.%s.%s", tvdbId, language)
if err := cacheStore.Get(key, &show); err != nil {
newShow, err := NewShow(tvdbId, language)
if err != nil {
return nil, err
}
if newShow != nil {
cacheStore.Set(key, newShow, cacheTime)
}
show = newShow
}
return show, nil
}
func ShowSeasons(ctx *gin.Context) {
show, err := tvdb.NewShowCached(ctx.Params.ByName("showId"), config.Get().Language)
if err != nil {
ctx.Error(err)
return
}
items := show.Seasons.ToListItems(show)
reversedItems := make(xbmc.ListItems, 0)
for i := len(items) - 1; i >= 0; i-- {
item := items[i]
item.Path = UrlForXBMC("/show/%d/season/%d/episodes", show.Id, item.Info.Season)
reversedItems = append(reversedItems, item)
}
// xbmc.ListItems always returns false to Less() so that order is unchanged
ctx.JSON(200, xbmc.NewView("seasons", reversedItems))
}
func showEpisodeLinks(showId string, seasonNumber, episodeNumber int) ([]*bittorrent.Torrent, error) {
log.Println("Searching links for TVDB Id:", showId)
show, err := tvdb.NewShowCached(showId, config.Get().Language)
if err != nil {
return nil, err
}
episode := show.Seasons[seasonNumber].Episodes[episodeNumber-1]
log.Printf("Resolved %s to %s\n", showId, show.SeriesName)
searchers := providers.GetEpisodeSearchers()
if len(searchers) == 0 {
xbmc.Notify("Pulsar", "LOCALIZE[30204]", config.AddonIcon())
}
return providers.SearchEpisode(searchers, show, episode), nil
}
func Find(externalId string, externalSource string) *FindResult {
var result *FindResult
cacheStore := cache.NewFileStore(path.Join(config.Get().ProfilePath, "cache"))
key := fmt.Sprintf("com.tmdb.find.%s.%s", externalSource, externalId)
if err := cacheStore.Get(key, &result); err != nil {
rateLimiter.Call(func() {
p := napping.Params{"api_key": apiKey, "external_source": externalSource}.AsUrlValues()
napping.Get(
tmdbEndpoint+"find/"+externalId,
&p,
&result,
nil,
)
cacheStore.Set(key, result, 365*24*time.Hour)
})
}
return result
}
func Play(btService *bittorrent.BTService) gin.HandlerFunc {
return func(ctx *gin.Context) {
uri := ctx.Request.URL.Query().Get("uri")
if uri == "" {
return
}
torrent := bittorrent.NewTorrent(uri)
magnet := torrent.Magnet()
boosters := url.Values{
"tr": providers.DefaultTrackers,
}
magnet += "&" + boosters.Encode()
player := bittorrent.NewBTPlayer(btService, magnet, config.Get().KeepFilesAfterStop == false)
if player.Buffer() != nil {
return
}
hostname := "localhost"
if localIP, err := util.LocalIP(); err == nil {
hostname = localIP.String()
}
rUrl, _ := url.Parse(fmt.Sprintf("http://%s:%d/files/%s", hostname, config.ListenPort, player.PlayURL()))
ctx.Redirect(302, rUrl.String())
}
}
func main() {
// Make sure we are properly multithreaded.
runtime.GOMAXPROCS(runtime.NumCPU())
logging.SetFormatter(logging.MustStringFormatter("%{time:2006-01-02 15:04:05} %{level:.4s} %{module:-15s} %{message}"))
logging.SetBackend(logging.NewLogBackend(os.Stdout, "", 0))
for _, line := range strings.Split(PulsarLogo, "\n") {
log.Info(line)
}
log.Info("Version: %s Git: %s Go: %s", util.Version, util.GitCommit, runtime.Version())
conf := config.Reload()
ensureSingleInstance()
Migrate()
xbmc.CloseAllDialogs()
log.Info("Addon: %s v%s", conf.Info.Id, conf.Info.Version)
btService := bittorrent.NewBTService(*makeBTConfiguration(conf))
var shutdown = func() {
log.Info("Shutting down...")
btService.Close()
log.Info("Bye bye")
os.Exit(0)
}
var watchParentProcess = func() {
for {
// did the parent die? shutdown!
if os.Getppid() == 1 {
log.Warning("Parent shut down. Me too.")
go shutdown()
break
}
time.Sleep(1 * time.Second)
}
}
go watchParentProcess()
http.Handle("/", api.Routes(btService))
http.Handle("/files/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handler := http.StripPrefix("/files/", http.FileServer(bittorrent.NewTorrentFS(btService, config.Get().DownloadPath)))
handler.ServeHTTP(w, r)
}))
http.Handle("/reload", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
btService.Reconfigure(*makeBTConfiguration(config.Reload()))
}))
http.Handle("/shutdown", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
shutdown()
}))
xbmc.Notify("Pulsar", "LOCALIZE[30208]", config.AddonIcon())
http.ListenAndServe(":"+strconv.Itoa(config.ListenPort), nil)
}
func (btp *BTPlayer) playerLoop() {
defer btp.Close()
//start := time.Now()
btp.log.Info("Buffer loop")
buffered, bufferDone := btp.bufferEvents.Listen()
defer close(bufferDone)
go btp.bufferDialog()
if err := <-buffered; err != nil {
return
}
//ga.TrackTiming("player", "buffer_time_real", int(time.Now().Sub(start).Seconds()*1000), "")
btp.log.Info("Waiting for playback...")
oneSecond := time.NewTicker(1 * time.Second)
defer oneSecond.Stop()
playbackTimeout := time.After(playbackMaxWait)
playbackWaitLoop:
for {
if xbmc.PlayerIsPlaying() {
break playbackWaitLoop
}
select {
case <-playbackTimeout:
btp.log.Info("Playback was unable to start after %d seconds. Aborting...", playbackMaxWait/time.Second)
btp.bufferEvents.Broadcast(errors.New("Playback was unable to start before timeout."))
return
case <-oneSecond.C:
// ga.TrackEvent("player", "waiting_playback", btp.torrentName, -1)
}
}
//ga.TrackTiming("player", "buffer_time_perceived", int(time.Now().Sub(start).Seconds()*1000), "")
btp.log.Info("Playback loop")
overlayStatusActive := false
//playingTicker := time.NewTicker(60 * time.Second)
//defer playingTicker.Stop()
playbackLoop:
for {
if xbmc.PlayerIsPlaying() == false {
btp.overlayStatus.Close()
break playbackLoop
}
select {
//case <-playingTicker.C:
// ga.TrackEvent("player", "playing", btp.torrentName, -1)
case <-oneSecond.C:
if xbmc.PlayerIsPaused() && config.Get().EnableOverlayStatus == true {
status := btp.torrentHandle.Status(uint(libtorrent.Torrent_handleQuery_name))
progress := float64(status.GetProgress())
line1, line2, line3 := btp.statusStrings(progress, status)
btp.overlayStatus.Update(int(progress), line1, line2, line3)
if overlayStatusActive == false {
btp.overlayStatus.Show()
overlayStatusActive = true
}
} else {
if overlayStatusActive == true {
btp.overlayStatus.Hide()
overlayStatusActive = false
}
}
}
}
//ga.TrackEvent("player", "stop", btp.torrentName, -1)
//ga.TrackTiming("player", "watched_time", int(time.Now().Sub(start).Seconds()*1000), "")
}
func ClearCache(ctx *gin.Context) {
os.RemoveAll(filepath.Join(config.Get().Info.Profile, "cache"))
xbmc.Notify("Pulsar", "LOCALIZE[30200]", config.AddonIcon())
}
func SubtitlesIndex(ctx *gin.Context) {
q := ctx.Request.URL.Query()
searchString := q.Get("searchstring")
languages := strings.Split(q.Get("languages"), ",")
labels := xbmc.InfoLabels(
"VideoPlayer.Title",
"VideoPlayer.OriginalTitle",
"VideoPlayer.Year",
"VideoPlayer.TVshowtitle",
"VideoPlayer.Season",
"VideoPlayer.Episode",
)
playingFile := xbmc.PlayerGetPlayingFile()
// are we reading a file from Pulsar?
if strings.HasPrefix(playingFile, util.GetHTTPHost()) {
playingFile = strings.Replace(playingFile, util.GetHTTPHost()+"/files", config.Get().DownloadPath, 1)
playingFile, _ = url.QueryUnescape(playingFile)
}
for i, lang := range languages {
if lang == "Portuguese (Brazil)" {
languages[i] = "pob"
} else {
isoLang := xbmc.ConvertLanguage(lang, xbmc.ISO_639_2)
if isoLang == "gre" {
isoLang = "ell"
}
languages[i] = isoLang
}
}
payloads := []osdb.SearchPayload{}
if searchString != "" {
payloads = append(payloads, osdb.SearchPayload{
Query: searchString,
Languages: strings.Join(languages, ","),
})
} else {
if strings.HasPrefix(playingFile, "http://") == false && strings.HasPrefix(playingFile, "https://") == false {
appendLocalFilePayloads(playingFile, &payloads)
}
if labels["VideoPlayer.TVshowtitle"] != "" {
appendEpisodePayloads(labels, &payloads)
} else {
appendMoviePayloads(labels, &payloads)
}
}
for i, payload := range payloads {
payload.Languages = strings.Join(languages, ",")
payloads[i] = payload
}
client, err := osdb.NewClient()
if err != nil {
ctx.AbortWithError(500, err)
return
}
if err := client.LogIn("", "", ""); err != nil {
ctx.AbortWithError(500, err)
return
}
items := make(xbmc.ListItems, 0)
results, _ := client.SearchSubtitles(payloads)
for _, sub := range results {
rating, _ := strconv.ParseFloat(sub.SubRating, 64)
subLang := sub.LanguageName
if subLang == "Brazilian" {
subLang = "Portuguese (Brazil)"
}
item := &xbmc.ListItem{
Label: subLang,
Label2: sub.SubFileName,
Icon: strconv.Itoa(int((rating / 2) + 0.5)),
Thumbnail: sub.ISO639,
Path: UrlQuery(UrlForXBMC("/subtitle/%s", sub.IDSubtitleFile),
"file", sub.SubFileName,
"lang", sub.SubLanguageID,
"fmt", sub.SubFormat,
"dl", sub.SubDownloadLink),
Properties: make(map[string]string),
}
if sub.MatchedBy == "moviehash" {
item.Properties["sync"] = "true"
}
if sub.SubHearingImpaired == "1" {
item.Properties["hearing_imp"] = "true"
}
items = append(items, item)
}
ctx.JSON(200, xbmc.NewView("", items))
}
func IMDBTop250(ctx *gin.Context) {
renderMovies(tmdb.GetList("522effe419c2955e9922fcf3", config.Get().Language), ctx, -1)
}